summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/mbgl/style/conversion.hpp5
-rw-r--r--include/mbgl/style/conversion/layer.hpp208
-rw-r--r--include/mbgl/style/conversion/make_property_setters.hpp133
-rw-r--r--include/mbgl/style/conversion/make_property_setters.hpp.ejs45
-rw-r--r--include/mbgl/style/conversion/property_setter.hpp55
-rw-r--r--include/mbgl/style/conversion/property_value.hpp4
-rw-r--r--include/mbgl/style/layers/background_layer.hpp6
-rw-r--r--include/mbgl/style/layers/circle_layer.hpp12
-rw-r--r--include/mbgl/style/layers/fill_layer.hpp14
-rw-r--r--include/mbgl/style/layers/layer.hpp.ejs2
-rw-r--r--include/mbgl/style/layers/line_layer.hpp20
-rw-r--r--include/mbgl/style/layers/raster_layer.hpp14
-rw-r--r--include/mbgl/style/layers/symbol_layer.hpp28
-rw-r--r--package.json2
-rw-r--r--platform/node/src/node_conversion.hpp25
-rw-r--r--platform/node/src/node_map.cpp119
-rw-r--r--platform/node/src/node_map.hpp5
-rw-r--r--platform/node/src/node_style.hpp67
-rw-r--r--platform/node/src/node_style_properties.hpp149
-rw-r--r--platform/node/src/node_style_properties.hpp.ejs53
-rw-r--r--scripts/generate-style-code.js4
-rw-r--r--src/mbgl/style/layer_impl.hpp5
-rw-r--r--src/mbgl/style/layers/background_layer.cpp20
-rw-r--r--src/mbgl/style/layers/background_layer_impl.cpp4
-rw-r--r--src/mbgl/style/layers/background_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/background_layer_properties.cpp6
-rw-r--r--src/mbgl/style/layers/background_layer_properties.hpp2
-rw-r--r--src/mbgl/style/layers/circle_layer.cpp32
-rw-r--r--src/mbgl/style/layers/circle_layer_impl.cpp4
-rw-r--r--src/mbgl/style/layers/circle_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/circle_layer_properties.cpp9
-rw-r--r--src/mbgl/style/layers/circle_layer_properties.hpp2
-rw-r--r--src/mbgl/style/layers/custom_layer_impl.cpp5
-rw-r--r--src/mbgl/style/layers/custom_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/fill_layer.cpp36
-rw-r--r--src/mbgl/style/layers/fill_layer_impl.cpp4
-rw-r--r--src/mbgl/style/layers/fill_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/fill_layer_properties.cpp10
-rw-r--r--src/mbgl/style/layers/fill_layer_properties.hpp2
-rw-r--r--src/mbgl/style/layers/layer.cpp.ejs12
-rw-r--r--src/mbgl/style/layers/layer_properties.cpp.ejs12
-rw-r--r--src/mbgl/style/layers/layer_properties.hpp.ejs3
-rw-r--r--src/mbgl/style/layers/line_layer.cpp48
-rw-r--r--src/mbgl/style/layers/line_layer_impl.cpp8
-rw-r--r--src/mbgl/style/layers/line_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/line_layer_properties.cpp20
-rw-r--r--src/mbgl/style/layers/line_layer_properties.hpp3
-rw-r--r--src/mbgl/style/layers/raster_layer.cpp36
-rw-r--r--src/mbgl/style/layers/raster_layer_impl.cpp4
-rw-r--r--src/mbgl/style/layers/raster_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/raster_layer_properties.cpp10
-rw-r--r--src/mbgl/style/layers/raster_layer_properties.hpp2
-rw-r--r--src/mbgl/style/layers/symbol_layer.cpp64
-rw-r--r--src/mbgl/style/layers/symbol_layer_impl.cpp8
-rw-r--r--src/mbgl/style/layers/symbol_layer_impl.hpp4
-rw-r--r--src/mbgl/style/layers/symbol_layer_properties.cpp54
-rw-r--r--src/mbgl/style/layers/symbol_layer_properties.hpp3
-rw-r--r--src/mbgl/style/layout_property.hpp7
-rw-r--r--src/mbgl/style/paint_property.hpp46
-rw-r--r--src/mbgl/style/parser.cpp118
-rw-r--r--src/mbgl/style/parser.hpp1
-rw-r--r--src/mbgl/style/rapidjson_conversion.hpp16
-rw-r--r--src/mbgl/style/style.cpp2
-rw-r--r--test/fixtures/style_parser/circle-blur.info.json2
-rw-r--r--test/fixtures/style_parser/circle-blur.style.json2
-rw-r--r--test/fixtures/style_parser/circle-color.info.json2
-rw-r--r--test/fixtures/style_parser/circle-color.style.json2
-rw-r--r--test/fixtures/style_parser/circle-opacity.info.json2
-rw-r--r--test/fixtures/style_parser/circle-opacity.style.json2
-rw-r--r--test/fixtures/style_parser/circle-radius.info.json2
-rw-r--r--test/fixtures/style_parser/circle-radius.style.json2
-rw-r--r--test/fixtures/style_parser/function-numeric.info.json2
-rw-r--r--test/fixtures/style_parser/function-type.info.json2
-rw-r--r--test/fixtures/style_parser/line-opacity.info.json2
-rw-r--r--test/fixtures/style_parser/line-opacity.style.json2
-rw-r--r--test/fixtures/style_parser/line-translate.info.json2
-rw-r--r--test/fixtures/style_parser/line-translate.style.json2
-rw-r--r--test/fixtures/style_parser/line-width.info.json2
-rw-r--r--test/fixtures/style_parser/line-width.style.json2
-rw-r--r--test/fixtures/style_parser/stop-zoom-value.info.json2
-rw-r--r--test/fixtures/style_parser/stops-array.info.json2
-rw-r--r--test/fixtures/style_parser/text-size.info.json2
-rw-r--r--test/fixtures/style_parser/text-size.style.json2
83 files changed, 841 insertions, 815 deletions
diff --git a/include/mbgl/style/conversion.hpp b/include/mbgl/style/conversion.hpp
index eff7e293a3..2cb3ced376 100644
--- a/include/mbgl/style/conversion.hpp
+++ b/include/mbgl/style/conversion.hpp
@@ -28,6 +28,8 @@ namespace conversion {
The implementation of `convert` requires that the following are legal expressions for a value `v`
of type `const V&`:
+ * `isUndefined(v)` -- returns a boolean indication whether `v` is undefined or a JSON null
+
* `isArray(v)` -- returns a boolean indicating whether `v` represents a JSON array
* `arrayLength(v)` -- called only if `isArray(v)`; returns a size_t length
* `arrayMember(v)` -- called only if `isArray(v)`; returns `V` or `V&`
@@ -36,6 +38,9 @@ namespace conversion {
* `objectMember(v, name)` -- called only if `isObject(v)`; `name` is `const char *`; return value:
* is true when evaluated in a boolean context iff the named member exists
* is convertable to a `V` or `V&` when dereferenced
+ * `eachMember(v, [] (const std::string&, const V&) -> optional<Error> {...})` -- called
+ only if `isObject(v)`; calls the provided lambda once for each key and value of the object;
+ short-circuits if any call returns an `Error`
* `toBool(v)` -- returns `optional<bool>`, absence indicating `v` is not a JSON boolean
* `toNumber(v)` -- returns `optional<float>`, absence indicating `v` is not a JSON number
diff --git a/include/mbgl/style/conversion/layer.hpp b/include/mbgl/style/conversion/layer.hpp
new file mode 100644
index 0000000000..0539dcf9ad
--- /dev/null
+++ b/include/mbgl/style/conversion/layer.hpp
@@ -0,0 +1,208 @@
+#pragma once
+
+#include <mbgl/style/layer.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/make_property_setters.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+optional<Error> setLayoutProperty(Layer& layer, const std::string& name, const V& value) {
+ static const auto setters = makeLayoutPropertySetters<V>();
+ auto it = setters.find(name);
+ if (it == setters.end()) {
+ return Error { "property not found" };
+ }
+ return it->second(layer, value);
+}
+
+template <class V>
+optional<Error> setPaintProperty(Layer& layer, const std::string& name, const V& value, const optional<std::string>& klass) {
+ static const auto setters = makePaintPropertySetters<V>();
+ auto it = setters.find(name);
+ if (it == setters.end()) {
+ return Error { "property not found" };
+ }
+ return it->second(layer, value, klass);
+}
+
+template <class V>
+optional<Error> setPaintProperties(Layer& layer, const V& value) {
+ return eachMember(value, [&] (const std::string& paintName, const V& paintValue) -> optional<Error> {
+ if (paintName.compare(0, 5, "paint") != 0) {
+ return {};
+ }
+
+ optional<std::string> klass;
+ if (paintName.compare(0, 6, "paint.") == 0) {
+ klass = paintName.substr(6);
+ }
+
+ return eachMember(paintValue, [&] (const std::string& k, const V& v) {
+ return setPaintProperty(layer, k, v, klass);
+ });
+ });
+}
+
+template <>
+struct Converter<std::unique_ptr<Layer>> {
+public:
+ template <class V>
+ Result<std::unique_ptr<Layer>> operator()(const V& value) const {
+ if (!isObject(value)) {
+ return Error { "layer must be an object" };
+ }
+
+ auto idValue = objectMember(value, "id");
+ if (!idValue) {
+ return Error { "layer must have an id" };
+ }
+
+ optional<std::string> id = toString(*idValue);
+ if (!id) {
+ return Error { "layer id must be a string" };
+ }
+
+ auto typeValue = objectMember(value, "type");
+ if (!typeValue) {
+ return Error { "layer must have a type" };
+ }
+
+ optional<std::string> type = toString(*typeValue);
+ if (!type) {
+ return Error { "layer type must be a string" };
+ }
+
+ Result<std::unique_ptr<Layer>> converted;
+
+ if (*type == "fill") {
+ converted = convertVectorLayer<FillLayer>(*id, value);
+ } else if (*type == "line") {
+ converted = convertVectorLayer<LineLayer>(*id, value);
+ } else if (*type == "circle") {
+ converted = convertVectorLayer<CircleLayer>(*id, value);
+ } else if (*type == "symbol") {
+ converted = convertVectorLayer<SymbolLayer>(*id, value);
+ } else if (*type == "raster") {
+ converted = convertRasterLayer(*id, value);
+ } else if (*type == "background") {
+ converted = convertBackgroundLayer(*id, value);
+ } else {
+ return Error { "invalid layer type" };
+ }
+
+ if (!converted) {
+ return converted;
+ }
+
+ std::unique_ptr<Layer> layer = std::move(*converted);
+
+ auto minzoomValue = objectMember(value, "minzoom");
+ if (minzoomValue) {
+ optional<float> minzoom = toNumber(*minzoomValue);
+ if (!minzoom) {
+ return Error { "minzoom must be numeric" };
+ }
+ layer->setMinZoom(*minzoom);
+ }
+
+ auto maxzoomValue = objectMember(value, "maxzoom");
+ if (maxzoomValue) {
+ optional<float> maxzoom = toNumber(*maxzoomValue);
+ if (!maxzoom) {
+ return Error { "maxzoom must be numeric" };
+ }
+ layer->setMaxZoom(*maxzoom);
+ }
+
+ auto layoutValue = objectMember(value, "layout");
+ if (layoutValue) {
+ if (!isObject(*layoutValue)) {
+ return Error { "layout must be an object" };
+ }
+ optional<Error> error = eachMember(*layoutValue, [&] (const std::string& k, const V& v) {
+ return setLayoutProperty(*layer, k, v);
+ });
+ if (error) {
+ return *error;
+ }
+ }
+
+ optional<Error> error = setPaintProperties(*layer, value);
+ if (error) {
+ return *error;
+ }
+
+ return std::move(layer);
+ }
+
+private:
+ template <class LayerType, class V>
+ Result<std::unique_ptr<Layer>> convertVectorLayer(const std::string& id, const V& value) const {
+ auto sourceValue = objectMember(value, "source");
+ if (!sourceValue) {
+ return Error { "layer must have a source" };
+ }
+
+ optional<std::string> source = toString(*sourceValue);
+ if (!source) {
+ return Error { "layer source must be a string" };
+ }
+
+ std::unique_ptr<LayerType> layer = std::make_unique<LayerType>(id, *source);
+
+ auto sourceLayerValue = objectMember(value, "source-layer");
+ if (sourceLayerValue) {
+ optional<std::string> sourceLayer = toString(*sourceLayerValue);
+ if (!sourceLayer) {
+ return Error { "layer source-layer must be a string" };
+ }
+ layer->setSourceLayer(*sourceLayer);
+ }
+
+ auto filterValue = objectMember(value, "filter");
+ if (filterValue) {
+ Result<Filter> filter = convert<Filter>(*filterValue);
+ if (!filter) {
+ return filter.error();
+ }
+ layer->setFilter(*filter);
+ }
+
+ return std::move(layer);
+ }
+
+ template <class V>
+ Result<std::unique_ptr<Layer>> convertRasterLayer(const std::string& id, const V& value) const {
+ auto sourceValue = objectMember(value, "source");
+ if (!sourceValue) {
+ return Error { "layer must have a source" };
+ }
+
+ optional<std::string> source = toString(*sourceValue);
+ if (!source) {
+ return Error { "layer source must be a string" };
+ }
+
+ return std::make_unique<RasterLayer>(id, *source);
+ }
+
+ template <class V>
+ Result<std::unique_ptr<Layer>> convertBackgroundLayer(const std::string& id, const V&) const {
+ return std::make_unique<BackgroundLayer>(id);
+ }
+};
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/make_property_setters.hpp b/include/mbgl/style/conversion/make_property_setters.hpp
new file mode 100644
index 0000000000..4c0089deaf
--- /dev/null
+++ b/include/mbgl/style/conversion/make_property_setters.hpp
@@ -0,0 +1,133 @@
+// This file is generated. Edit make_property_setters.hpp.ejs, then run `make style-code`.
+
+#include <mbgl/style/conversion/property_setter.hpp>
+
+#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
+#include <mbgl/style/layers/circle_layer.hpp>
+#include <mbgl/style/layers/raster_layer.hpp>
+#include <mbgl/style/layers/background_layer.hpp>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+auto makeLayoutPropertySetters() {
+ std::unordered_map<std::string, LayoutPropertySetter<V>> result;
+
+ result["visibility"] = &setVisibility<V>;
+
+
+ result["line-cap"] = makePropertySetter<V>(&LineLayer::setLineCap);
+ result["line-join"] = makePropertySetter<V>(&LineLayer::setLineJoin);
+ result["line-miter-limit"] = makePropertySetter<V>(&LineLayer::setLineMiterLimit);
+ result["line-round-limit"] = makePropertySetter<V>(&LineLayer::setLineRoundLimit);
+
+ result["symbol-placement"] = makePropertySetter<V>(&SymbolLayer::setSymbolPlacement);
+ result["symbol-spacing"] = makePropertySetter<V>(&SymbolLayer::setSymbolSpacing);
+ result["symbol-avoid-edges"] = makePropertySetter<V>(&SymbolLayer::setSymbolAvoidEdges);
+ result["icon-allow-overlap"] = makePropertySetter<V>(&SymbolLayer::setIconAllowOverlap);
+ result["icon-ignore-placement"] = makePropertySetter<V>(&SymbolLayer::setIconIgnorePlacement);
+ result["icon-optional"] = makePropertySetter<V>(&SymbolLayer::setIconOptional);
+ result["icon-rotation-alignment"] = makePropertySetter<V>(&SymbolLayer::setIconRotationAlignment);
+ result["icon-size"] = makePropertySetter<V>(&SymbolLayer::setIconSize);
+ result["icon-text-fit"] = makePropertySetter<V>(&SymbolLayer::setIconTextFit);
+ result["icon-text-fit-padding"] = makePropertySetter<V>(&SymbolLayer::setIconTextFitPadding);
+ result["icon-image"] = makePropertySetter<V>(&SymbolLayer::setIconImage);
+ result["icon-rotate"] = makePropertySetter<V>(&SymbolLayer::setIconRotate);
+ result["icon-padding"] = makePropertySetter<V>(&SymbolLayer::setIconPadding);
+ result["icon-keep-upright"] = makePropertySetter<V>(&SymbolLayer::setIconKeepUpright);
+ result["icon-offset"] = makePropertySetter<V>(&SymbolLayer::setIconOffset);
+ result["text-pitch-alignment"] = makePropertySetter<V>(&SymbolLayer::setTextPitchAlignment);
+ result["text-rotation-alignment"] = makePropertySetter<V>(&SymbolLayer::setTextRotationAlignment);
+ result["text-field"] = makePropertySetter<V>(&SymbolLayer::setTextField);
+ result["text-font"] = makePropertySetter<V>(&SymbolLayer::setTextFont);
+ result["text-size"] = makePropertySetter<V>(&SymbolLayer::setTextSize);
+ result["text-max-width"] = makePropertySetter<V>(&SymbolLayer::setTextMaxWidth);
+ result["text-line-height"] = makePropertySetter<V>(&SymbolLayer::setTextLineHeight);
+ result["text-letter-spacing"] = makePropertySetter<V>(&SymbolLayer::setTextLetterSpacing);
+ result["text-justify"] = makePropertySetter<V>(&SymbolLayer::setTextJustify);
+ result["text-anchor"] = makePropertySetter<V>(&SymbolLayer::setTextAnchor);
+ result["text-max-angle"] = makePropertySetter<V>(&SymbolLayer::setTextMaxAngle);
+ result["text-rotate"] = makePropertySetter<V>(&SymbolLayer::setTextRotate);
+ result["text-padding"] = makePropertySetter<V>(&SymbolLayer::setTextPadding);
+ result["text-keep-upright"] = makePropertySetter<V>(&SymbolLayer::setTextKeepUpright);
+ result["text-transform"] = makePropertySetter<V>(&SymbolLayer::setTextTransform);
+ result["text-offset"] = makePropertySetter<V>(&SymbolLayer::setTextOffset);
+ result["text-allow-overlap"] = makePropertySetter<V>(&SymbolLayer::setTextAllowOverlap);
+ result["text-ignore-placement"] = makePropertySetter<V>(&SymbolLayer::setTextIgnorePlacement);
+ result["text-optional"] = makePropertySetter<V>(&SymbolLayer::setTextOptional);
+
+
+
+
+ return result;
+}
+
+template <class V>
+auto makePaintPropertySetters() {
+ std::unordered_map<std::string, PaintPropertySetter<V>> result;
+
+ result["fill-antialias"] = makePropertySetter<V>(&FillLayer::setFillAntialias);
+ result["fill-opacity"] = makePropertySetter<V>(&FillLayer::setFillOpacity);
+ result["fill-color"] = makePropertySetter<V>(&FillLayer::setFillColor);
+ result["fill-outline-color"] = makePropertySetter<V>(&FillLayer::setFillOutlineColor);
+ result["fill-translate"] = makePropertySetter<V>(&FillLayer::setFillTranslate);
+ result["fill-translate-anchor"] = makePropertySetter<V>(&FillLayer::setFillTranslateAnchor);
+ result["fill-pattern"] = makePropertySetter<V>(&FillLayer::setFillPattern);
+
+ result["line-opacity"] = makePropertySetter<V>(&LineLayer::setLineOpacity);
+ result["line-color"] = makePropertySetter<V>(&LineLayer::setLineColor);
+ result["line-translate"] = makePropertySetter<V>(&LineLayer::setLineTranslate);
+ result["line-translate-anchor"] = makePropertySetter<V>(&LineLayer::setLineTranslateAnchor);
+ result["line-width"] = makePropertySetter<V>(&LineLayer::setLineWidth);
+ result["line-gap-width"] = makePropertySetter<V>(&LineLayer::setLineGapWidth);
+ result["line-offset"] = makePropertySetter<V>(&LineLayer::setLineOffset);
+ result["line-blur"] = makePropertySetter<V>(&LineLayer::setLineBlur);
+ result["line-dasharray"] = makePropertySetter<V>(&LineLayer::setLineDasharray);
+ result["line-pattern"] = makePropertySetter<V>(&LineLayer::setLinePattern);
+
+ result["icon-opacity"] = makePropertySetter<V>(&SymbolLayer::setIconOpacity);
+ result["icon-color"] = makePropertySetter<V>(&SymbolLayer::setIconColor);
+ result["icon-halo-color"] = makePropertySetter<V>(&SymbolLayer::setIconHaloColor);
+ result["icon-halo-width"] = makePropertySetter<V>(&SymbolLayer::setIconHaloWidth);
+ result["icon-halo-blur"] = makePropertySetter<V>(&SymbolLayer::setIconHaloBlur);
+ result["icon-translate"] = makePropertySetter<V>(&SymbolLayer::setIconTranslate);
+ result["icon-translate-anchor"] = makePropertySetter<V>(&SymbolLayer::setIconTranslateAnchor);
+ result["text-opacity"] = makePropertySetter<V>(&SymbolLayer::setTextOpacity);
+ result["text-color"] = makePropertySetter<V>(&SymbolLayer::setTextColor);
+ result["text-halo-color"] = makePropertySetter<V>(&SymbolLayer::setTextHaloColor);
+ result["text-halo-width"] = makePropertySetter<V>(&SymbolLayer::setTextHaloWidth);
+ result["text-halo-blur"] = makePropertySetter<V>(&SymbolLayer::setTextHaloBlur);
+ result["text-translate"] = makePropertySetter<V>(&SymbolLayer::setTextTranslate);
+ result["text-translate-anchor"] = makePropertySetter<V>(&SymbolLayer::setTextTranslateAnchor);
+
+ result["circle-radius"] = makePropertySetter<V>(&CircleLayer::setCircleRadius);
+ result["circle-color"] = makePropertySetter<V>(&CircleLayer::setCircleColor);
+ result["circle-blur"] = makePropertySetter<V>(&CircleLayer::setCircleBlur);
+ result["circle-opacity"] = makePropertySetter<V>(&CircleLayer::setCircleOpacity);
+ result["circle-translate"] = makePropertySetter<V>(&CircleLayer::setCircleTranslate);
+ result["circle-translate-anchor"] = makePropertySetter<V>(&CircleLayer::setCircleTranslateAnchor);
+
+ result["raster-opacity"] = makePropertySetter<V>(&RasterLayer::setRasterOpacity);
+ result["raster-hue-rotate"] = makePropertySetter<V>(&RasterLayer::setRasterHueRotate);
+ result["raster-brightness-min"] = makePropertySetter<V>(&RasterLayer::setRasterBrightnessMin);
+ result["raster-brightness-max"] = makePropertySetter<V>(&RasterLayer::setRasterBrightnessMax);
+ result["raster-saturation"] = makePropertySetter<V>(&RasterLayer::setRasterSaturation);
+ result["raster-contrast"] = makePropertySetter<V>(&RasterLayer::setRasterContrast);
+ result["raster-fade-duration"] = makePropertySetter<V>(&RasterLayer::setRasterFadeDuration);
+
+ result["background-color"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundColor);
+ result["background-pattern"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundPattern);
+ result["background-opacity"] = makePropertySetter<V>(&BackgroundLayer::setBackgroundOpacity);
+
+ return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/make_property_setters.hpp.ejs b/include/mbgl/style/conversion/make_property_setters.hpp.ejs
new file mode 100644
index 0000000000..493c68ea31
--- /dev/null
+++ b/include/mbgl/style/conversion/make_property_setters.hpp.ejs
@@ -0,0 +1,45 @@
+// This file is generated. Edit make_property_setters.hpp.ejs, then run `make style-code`.
+
+#include <mbgl/style/conversion/property_setter.hpp>
+
+<% for (const layer of locals.layers) { -%>
+#include <mbgl/style/layers/<%- layer.type %>_layer.hpp>
+<% } -%>
+
+#include <unordered_map>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+auto makeLayoutPropertySetters() {
+ std::unordered_map<std::string, LayoutPropertySetter<V>> result;
+
+ result["visibility"] = &setVisibility<V>;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.layoutProperties) { -%>
+ result["<%- property.name %>"] = makePropertySetter<V>(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
+<% } -%>
+
+<% } -%>
+ return result;
+}
+
+template <class V>
+auto makePaintPropertySetters() {
+ std::unordered_map<std::string, PaintPropertySetter<V>> result;
+
+<% for (const layer of locals.layers) { -%>
+<% for (const property of layer.paintProperties) { -%>
+ result["<%- property.name %>"] = makePropertySetter<V>(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
+<% } -%>
+
+<% } -%>
+ return result;
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/property_setter.hpp b/include/mbgl/style/conversion/property_setter.hpp
new file mode 100644
index 0000000000..38dd934252
--- /dev/null
+++ b/include/mbgl/style/conversion/property_setter.hpp
@@ -0,0 +1,55 @@
+#include <mbgl/style/layer.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+
+#include <functional>
+#include <string>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <class V>
+using LayoutPropertySetter = std::function<optional<Error> (Layer&, const V&)>;
+
+template <class V>
+using PaintPropertySetter = std::function<optional<Error> (Layer&, const V&, const optional<std::string>&)>;
+
+template <class V, class L, class T, class...Args>
+auto makePropertySetter(void (L::*setter)(PropertyValue<T>, const Args&...args)) {
+ return [setter] (Layer& layer, const V& value, const Args&...args) -> optional<Error> {
+ L* typedLayer = layer.as<L>();
+ if (!typedLayer) {
+ return Error { "layer doesn't support this property" };
+ }
+
+ Result<PropertyValue<T>> typedValue = convert<PropertyValue<T>>(value);
+ if (!typedValue) {
+ return typedValue.error();
+ }
+
+ (typedLayer->*setter)(*typedValue, args...);
+ return {};
+ };
+}
+
+template <class V>
+optional<Error> setVisibility(Layer& layer, const V& value) {
+ if (isUndefined(value)) {
+ layer.setVisibility(VisibilityType::Visible);
+ return {};
+ }
+
+ Result<VisibilityType> visibility = convert<VisibilityType>(value);
+ if (!visibility) {
+ return visibility.error();
+ }
+
+ layer.setVisibility(*visibility);
+ return {};
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/property_value.hpp b/include/mbgl/style/conversion/property_value.hpp
index 840643abbe..de95b56155 100644
--- a/include/mbgl/style/conversion/property_value.hpp
+++ b/include/mbgl/style/conversion/property_value.hpp
@@ -13,7 +13,9 @@ template <class T>
struct Converter<PropertyValue<T>> {
template <class V>
Result<PropertyValue<T>> operator()(const V& value) const {
- if (isObject(value)) {
+ if (isUndefined(value)) {
+ return {};
+ } else if (isObject(value)) {
Result<Function<T>> function = convert<Function<T>>(value);
if (!function) {
return function.error();
diff --git a/include/mbgl/style/layers/background_layer.hpp b/include/mbgl/style/layers/background_layer.hpp
index 2eb84ee499..ac97ec2e6d 100644
--- a/include/mbgl/style/layers/background_layer.hpp
+++ b/include/mbgl/style/layers/background_layer.hpp
@@ -19,13 +19,13 @@ public:
// Paint properties
PropertyValue<Color> getBackgroundColor() const;
- void setBackgroundColor(PropertyValue<Color>);
+ void setBackgroundColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<std::string> getBackgroundPattern() const;
- void setBackgroundPattern(PropertyValue<std::string>);
+ void setBackgroundPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
PropertyValue<float> getBackgroundOpacity() const;
- void setBackgroundOpacity(PropertyValue<float>);
+ void setBackgroundOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/include/mbgl/style/layers/circle_layer.hpp b/include/mbgl/style/layers/circle_layer.hpp
index 9c2b458d4b..c8d99ab30e 100644
--- a/include/mbgl/style/layers/circle_layer.hpp
+++ b/include/mbgl/style/layers/circle_layer.hpp
@@ -27,22 +27,22 @@ public:
// Paint properties
PropertyValue<float> getCircleRadius() const;
- void setCircleRadius(PropertyValue<float>);
+ void setCircleRadius(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<Color> getCircleColor() const;
- void setCircleColor(PropertyValue<Color>);
+ void setCircleColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<float> getCircleBlur() const;
- void setCircleBlur(PropertyValue<float>);
+ void setCircleBlur(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getCircleOpacity() const;
- void setCircleOpacity(PropertyValue<float>);
+ void setCircleOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<std::array<float, 2>> getCircleTranslate() const;
- void setCircleTranslate(PropertyValue<std::array<float, 2>>);
+ void setCircleTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
PropertyValue<TranslateAnchorType> getCircleTranslateAnchor() const;
- void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>);
+ void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/include/mbgl/style/layers/fill_layer.hpp b/include/mbgl/style/layers/fill_layer.hpp
index 90538dd3ea..e70d67f538 100644
--- a/include/mbgl/style/layers/fill_layer.hpp
+++ b/include/mbgl/style/layers/fill_layer.hpp
@@ -27,25 +27,25 @@ public:
// Paint properties
PropertyValue<bool> getFillAntialias() const;
- void setFillAntialias(PropertyValue<bool>);
+ void setFillAntialias(PropertyValue<bool>, const optional<std::string>& klass = {});
PropertyValue<float> getFillOpacity() const;
- void setFillOpacity(PropertyValue<float>);
+ void setFillOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<Color> getFillColor() const;
- void setFillColor(PropertyValue<Color>);
+ void setFillColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<Color> getFillOutlineColor() const;
- void setFillOutlineColor(PropertyValue<Color>);
+ void setFillOutlineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<std::array<float, 2>> getFillTranslate() const;
- void setFillTranslate(PropertyValue<std::array<float, 2>>);
+ void setFillTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
PropertyValue<TranslateAnchorType> getFillTranslateAnchor() const;
- void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>);
+ void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
PropertyValue<std::string> getFillPattern() const;
- void setFillPattern(PropertyValue<std::string>);
+ void setFillPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs
index 60365be906..aaae30287c 100644
--- a/include/mbgl/style/layers/layer.hpp.ejs
+++ b/include/mbgl/style/layers/layer.hpp.ejs
@@ -54,7 +54,7 @@ public:
<% for (const property of paintProperties) { -%>
PropertyValue<<%- propertyType(property) %>> get<%- camelize(property.name) %>() const;
- void set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>>);
+ void set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>>, const optional<std::string>& klass = {});
<% } -%>
// Private implementation
diff --git a/include/mbgl/style/layers/line_layer.hpp b/include/mbgl/style/layers/line_layer.hpp
index 4ffeee114a..abcb425b96 100644
--- a/include/mbgl/style/layers/line_layer.hpp
+++ b/include/mbgl/style/layers/line_layer.hpp
@@ -43,34 +43,34 @@ public:
// Paint properties
PropertyValue<float> getLineOpacity() const;
- void setLineOpacity(PropertyValue<float>);
+ void setLineOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<Color> getLineColor() const;
- void setLineColor(PropertyValue<Color>);
+ void setLineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<std::array<float, 2>> getLineTranslate() const;
- void setLineTranslate(PropertyValue<std::array<float, 2>>);
+ void setLineTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
PropertyValue<TranslateAnchorType> getLineTranslateAnchor() const;
- void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>);
+ void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
PropertyValue<float> getLineWidth() const;
- void setLineWidth(PropertyValue<float>);
+ void setLineWidth(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getLineGapWidth() const;
- void setLineGapWidth(PropertyValue<float>);
+ void setLineGapWidth(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getLineOffset() const;
- void setLineOffset(PropertyValue<float>);
+ void setLineOffset(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getLineBlur() const;
- void setLineBlur(PropertyValue<float>);
+ void setLineBlur(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<std::vector<float>> getLineDasharray() const;
- void setLineDasharray(PropertyValue<std::vector<float>>);
+ void setLineDasharray(PropertyValue<std::vector<float>>, const optional<std::string>& klass = {});
PropertyValue<std::string> getLinePattern() const;
- void setLinePattern(PropertyValue<std::string>);
+ void setLinePattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/include/mbgl/style/layers/raster_layer.hpp b/include/mbgl/style/layers/raster_layer.hpp
index 372434e46d..dea0c26bf3 100644
--- a/include/mbgl/style/layers/raster_layer.hpp
+++ b/include/mbgl/style/layers/raster_layer.hpp
@@ -22,25 +22,25 @@ public:
// Paint properties
PropertyValue<float> getRasterOpacity() const;
- void setRasterOpacity(PropertyValue<float>);
+ void setRasterOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterHueRotate() const;
- void setRasterHueRotate(PropertyValue<float>);
+ void setRasterHueRotate(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterBrightnessMin() const;
- void setRasterBrightnessMin(PropertyValue<float>);
+ void setRasterBrightnessMin(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterBrightnessMax() const;
- void setRasterBrightnessMax(PropertyValue<float>);
+ void setRasterBrightnessMax(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterSaturation() const;
- void setRasterSaturation(PropertyValue<float>);
+ void setRasterSaturation(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterContrast() const;
- void setRasterContrast(PropertyValue<float>);
+ void setRasterContrast(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getRasterFadeDuration() const;
- void setRasterFadeDuration(PropertyValue<float>);
+ void setRasterFadeDuration(PropertyValue<float>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp
index b21c8deaf7..77b63d9b91 100644
--- a/include/mbgl/style/layers/symbol_layer.hpp
+++ b/include/mbgl/style/layers/symbol_layer.hpp
@@ -133,46 +133,46 @@ public:
// Paint properties
PropertyValue<float> getIconOpacity() const;
- void setIconOpacity(PropertyValue<float>);
+ void setIconOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<Color> getIconColor() const;
- void setIconColor(PropertyValue<Color>);
+ void setIconColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<Color> getIconHaloColor() const;
- void setIconHaloColor(PropertyValue<Color>);
+ void setIconHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<float> getIconHaloWidth() const;
- void setIconHaloWidth(PropertyValue<float>);
+ void setIconHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getIconHaloBlur() const;
- void setIconHaloBlur(PropertyValue<float>);
+ void setIconHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<std::array<float, 2>> getIconTranslate() const;
- void setIconTranslate(PropertyValue<std::array<float, 2>>);
+ void setIconTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
PropertyValue<TranslateAnchorType> getIconTranslateAnchor() const;
- void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>);
+ void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
PropertyValue<float> getTextOpacity() const;
- void setTextOpacity(PropertyValue<float>);
+ void setTextOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<Color> getTextColor() const;
- void setTextColor(PropertyValue<Color>);
+ void setTextColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<Color> getTextHaloColor() const;
- void setTextHaloColor(PropertyValue<Color>);
+ void setTextHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
PropertyValue<float> getTextHaloWidth() const;
- void setTextHaloWidth(PropertyValue<float>);
+ void setTextHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<float> getTextHaloBlur() const;
- void setTextHaloBlur(PropertyValue<float>);
+ void setTextHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
PropertyValue<std::array<float, 2>> getTextTranslate() const;
- void setTextTranslate(PropertyValue<std::array<float, 2>>);
+ void setTextTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
PropertyValue<TranslateAnchorType> getTextTranslateAnchor() const;
- void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>);
+ void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
// Private implementation
diff --git a/package.json b/package.json
index 592559175f..97edceb9c9 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
"express": "^4.11.1",
"mapbox-gl-shaders": "mapbox/mapbox-gl-shaders#59e998295d548f208ee3ec10cdd21ff2630e2079",
"mapbox-gl-style-spec": "mapbox/mapbox-gl-style-spec#194fc55b6a7dd54c1e2cf2dd9048fbb5e836716d",
- "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#9a7de2fb72607be6ffa0040bf3d84651719a45e3",
+ "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#1633d164231dddf006777366de82178bf34fe866",
"node-gyp": "^3.3.1",
"request": "^2.72.0",
"tape": "^4.5.1"
diff --git a/platform/node/src/node_conversion.hpp b/platform/node/src/node_conversion.hpp
index 03c13b5846..2418a7a6e4 100644
--- a/platform/node/src/node_conversion.hpp
+++ b/platform/node/src/node_conversion.hpp
@@ -8,11 +8,17 @@
#include <mbgl/util/optional.hpp>
#include <mbgl/util/feature.hpp>
+#include <mbgl/style/conversion.hpp>
namespace mbgl {
namespace style {
namespace conversion {
+inline bool isUndefined(v8::Local<v8::Value> value) {
+ Nan::HandleScope scope;
+ return value->IsUndefined() || value->IsNull();
+}
+
inline bool isArray(v8::Local<v8::Value> value) {
Nan::HandleScope scope;
return value->IsArray();
@@ -35,16 +41,31 @@ inline bool isObject(v8::Local<v8::Value> value) {
inline optional<v8::Local<v8::Value>> objectMember(v8::Local<v8::Value> value, const char * name) {
Nan::EscapableHandleScope scope;
- if (!Nan::Has(value.As<v8::Array>(), Nan::New(name).ToLocalChecked()).FromJust()) {
+ if (!Nan::Has(value->ToObject(), Nan::New(name).ToLocalChecked()).FromJust()) {
return {};
}
- Nan::MaybeLocal<v8::Value> result = Nan::Get(value.As<v8::Array>(), Nan::New(name).ToLocalChecked());
+ Nan::MaybeLocal<v8::Value> result = Nan::Get(value->ToObject(), Nan::New(name).ToLocalChecked());
if (result.IsEmpty()) {
return {};
}
return scope.Escape(result.ToLocalChecked());
}
+template <class Fn>
+optional<Error> eachMember(v8::Local<v8::Value> value, Fn&& fn) {
+ Nan::HandleScope scope;
+ v8::Local<v8::Array> names = value->ToObject()->GetOwnPropertyNames();
+ for (uint32_t i = 0; i < names->Length(); ++i) {
+ v8::Local<v8::Value> k = Nan::Get(names, i).ToLocalChecked();
+ v8::Local<v8::Value> v = Nan::Get(value->ToObject(), k).ToLocalChecked();
+ optional<Error> result = fn(*Nan::Utf8String(k), v);
+ if (result) {
+ return result;
+ }
+ }
+ return {};
+}
+
inline optional<bool> toBool(v8::Local<v8::Value> value) {
Nan::HandleScope scope;
if (!value->IsBoolean()) {
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index e6ee84ee53..c73d3850f2 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -1,12 +1,12 @@
#include "node_map.hpp"
#include "node_request.hpp"
#include "node_feature.hpp"
-#include "node_style_properties.hpp"
+#include "node_conversion.hpp"
#include <mbgl/platform/default/headless_display.hpp>
#include <mbgl/util/exception.hpp>
-#include <mbgl/style/layer.hpp>
-#include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/conversion/layer.hpp>
+#include <mbgl/style/conversion/filter.hpp>
#include <unistd.h>
@@ -56,6 +56,7 @@ NAN_MODULE_INIT(NodeMap::Init) {
Nan::SetPrototypeMethod(tpl, "release", Release);
Nan::SetPrototypeMethod(tpl, "addClass", AddClass);
+ Nan::SetPrototypeMethod(tpl, "addLayer", AddLayer);
Nan::SetPrototypeMethod(tpl, "setLayoutProperty", SetLayoutProperty);
Nan::SetPrototypeMethod(tpl, "setPaintProperty", SetPaintProperty);
Nan::SetPrototypeMethod(tpl, "setFilter", SetFilter);
@@ -483,7 +484,30 @@ NAN_METHOD(NodeMap::AddClass) {
info.GetReturnValue().SetUndefined();
}
-void NodeMap::setProperty(const Nan::FunctionCallbackInfo<v8::Value>& info, const PropertySetters& setters) {
+NAN_METHOD(NodeMap::AddLayer) {
+ using namespace mbgl::style;
+ using namespace mbgl::style::conversion;
+
+ auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
+ if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
+
+ if (info.Length() != 1) {
+ return Nan::ThrowTypeError("One argument required");
+ }
+
+ Result<std::unique_ptr<Layer>> layer = convert<std::unique_ptr<Layer>>(info[0]);
+ if (!layer) {
+ Nan::ThrowTypeError(layer.error().message);
+ return;
+ }
+
+ nodeMap->map->addLayer(std::move(*layer));
+}
+
+NAN_METHOD(NodeMap::SetLayoutProperty) {
+ using namespace mbgl::style;
+ using namespace mbgl::style::conversion;
+
auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
@@ -504,30 +528,57 @@ void NodeMap::setProperty(const Nan::FunctionCallbackInfo<v8::Value>& info, cons
return Nan::ThrowTypeError("Second argument must be a string");
}
- auto it = setters.find(*Nan::Utf8String(info[1]));
- if (it == setters.end()) {
- return Nan::ThrowTypeError("property not found");
- }
-
- if (!it->second(*layer, info[2])) {
- return;
+ mbgl::optional<Error> error = setLayoutProperty(*layer, *Nan::Utf8String(info[1]), info[2]);
+ if (error) {
+ return Nan::ThrowTypeError(error->message);
}
nodeMap->map->update(mbgl::Update::RecalculateStyle);
info.GetReturnValue().SetUndefined();
}
-NAN_METHOD(NodeMap::SetLayoutProperty) {
- static const PropertySetters setters = makeLayoutPropertySetters();
- setProperty(info, setters);
-}
-
NAN_METHOD(NodeMap::SetPaintProperty) {
- static const PropertySetters setters = makePaintPropertySetters();
- setProperty(info, setters);
+ using namespace mbgl::style;
+ using namespace mbgl::style::conversion;
+
+ auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
+ if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
+
+ if (info.Length() < 3) {
+ return Nan::ThrowTypeError("Three arguments required");
+ }
+
+ if (!info[0]->IsString()) {
+ return Nan::ThrowTypeError("First argument must be a string");
+ }
+
+ mbgl::style::Layer* layer = nodeMap->map->getLayer(*Nan::Utf8String(info[0]));
+ if (!layer) {
+ return Nan::ThrowTypeError("layer not found");
+ }
+
+ if (!info[1]->IsString()) {
+ return Nan::ThrowTypeError("Second argument must be a string");
+ }
+
+ mbgl::optional<std::string> klass;
+ if (info.Length() == 4 && info[3]->IsString()) {
+ klass = std::string(*Nan::Utf8String(info[3]));
+ }
+
+ mbgl::optional<Error> error = setPaintProperty(*layer, *Nan::Utf8String(info[1]), info[2], klass);
+ if (error) {
+ return Nan::ThrowTypeError(error->message);
+ }
+
+ nodeMap->map->update(mbgl::Update::RecalculateStyle);
+ info.GetReturnValue().SetUndefined();
}
NAN_METHOD(NodeMap::SetFilter) {
+ using namespace mbgl::style;
+ using namespace mbgl::style::conversion;
+
auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
@@ -544,23 +595,39 @@ NAN_METHOD(NodeMap::SetFilter) {
return Nan::ThrowTypeError("layer not found");
}
- mbgl::style::Filter filter;
+ Filter filter;
if (!info[1]->IsNull() && !info[1]->IsUndefined()) {
- mbgl::style::conversion::Result<mbgl::style::Filter> converted
- = mbgl::style::conversion::convertFilter(info[1]);
- if (converted.is<mbgl::style::conversion::Error>()) {
- Nan::ThrowTypeError(converted.get<mbgl::style::conversion::Error>().message);
+ Result<Filter> converted = convert<Filter>(info[1]);
+ if (!converted) {
+ Nan::ThrowTypeError(converted.error().message);
return;
}
- filter = std::move(converted.get<mbgl::style::Filter>());
+ filter = std::move(*converted);
}
- if (!setFilter(*layer, filter)) {
+ if (layer->is<FillLayer>()) {
+ layer->as<FillLayer>()->setFilter(filter);
+ info.GetReturnValue().SetUndefined();
+ return;
+ }
+ if (layer->is<LineLayer>()) {
+ layer->as<LineLayer>()->setFilter(filter);
+ info.GetReturnValue().SetUndefined();
+ return;
+ }
+ if (layer->is<SymbolLayer>()) {
+ layer->as<SymbolLayer>()->setFilter(filter);
+ info.GetReturnValue().SetUndefined();
+ return;
+ }
+ if (layer->is<CircleLayer>()) {
+ layer->as<CircleLayer>()->setFilter(filter);
+ info.GetReturnValue().SetUndefined();
return;
}
- info.GetReturnValue().SetUndefined();
+ Nan::ThrowTypeError("layer doesn't support filters");
}
NAN_METHOD(NodeMap::DumpDebugLogs) {
diff --git a/platform/node/src/node_map.hpp b/platform/node/src/node_map.hpp
index 58773e33da..8e4b073134 100644
--- a/platform/node/src/node_map.hpp
+++ b/platform/node/src/node_map.hpp
@@ -1,7 +1,5 @@
#pragma once
-#include "node_style.hpp"
-
#include <mbgl/map/map.hpp>
#include <mbgl/storage/file_source.hpp>
#include <mbgl/platform/default/headless_view.hpp>
@@ -28,14 +26,13 @@ public:
static NAN_METHOD(Render);
static NAN_METHOD(Release);
static NAN_METHOD(AddClass);
+ static NAN_METHOD(AddLayer);
static NAN_METHOD(SetLayoutProperty);
static NAN_METHOD(SetPaintProperty);
static NAN_METHOD(SetFilter);
static NAN_METHOD(DumpDebugLogs);
static NAN_METHOD(QueryRenderedFeatures);
- static void setProperty(const Nan::FunctionCallbackInfo<v8::Value>&, const PropertySetters&);
-
void startRender(RenderOptions options);
void renderFinished();
diff --git a/platform/node/src/node_style.hpp b/platform/node/src/node_style.hpp
deleted file mode 100644
index 9befd00d10..0000000000
--- a/platform/node/src/node_style.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-#include "node_conversion.hpp"
-
-#include <mbgl/style/layer.hpp>
-#include <mbgl/style/conversion.hpp>
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wshadow"
-#include <nan.h>
-#pragma GCC diagnostic pop
-
-#include <functional>
-#include <string>
-#include <unordered_map>
-
-namespace node_mbgl {
-
-using PropertySetter = std::function<bool (mbgl::style::Layer&, const v8::Local<v8::Value>&)>;
-using PropertySetters = std::unordered_map<std::string, PropertySetter>;
-
-template <class L, class V>
-PropertySetter makePropertySetter(void (L::*setter)(mbgl::style::PropertyValue<V>)) {
- return [setter] (mbgl::style::Layer& layer, const v8::Local<v8::Value>& value) {
- L* typedLayer = layer.as<L>();
- if (!typedLayer) {
- Nan::ThrowTypeError("layer doesn't support this property");
- return false;
- }
-
- if (value->IsNull() || value->IsUndefined()) {
- (typedLayer->*setter)(mbgl::style::PropertyValue<V>());
- return true;
- }
-
- mbgl::style::conversion::Result<mbgl::style::PropertyValue<V>> typedValue
- = mbgl::style::conversion::convertPropertyValue<V>(value);
- if (typedValue.template is<mbgl::style::conversion::Error>()) {
- Nan::ThrowTypeError(typedValue.template get<mbgl::style::conversion::Error>().message);
- return false;
- }
-
- (typedLayer->*setter)(typedValue.template get<mbgl::style::PropertyValue<V>>());
- return true;
- };
-}
-
-inline bool setVisibility(mbgl::style::Layer& layer, const v8::Local<v8::Value>& value) {
- if (value->IsNull() || value->IsUndefined()) {
- layer.setVisibility(mbgl::style::VisibilityType::Visible);
- return true;
- }
-
- if (!value->IsString()) {
- Nan::ThrowTypeError("visibility value must be \"visible\" or \"none\"");
- return false;
- }
-
- layer.setVisibility(std::string(*Nan::Utf8String(value)) == "none"
- ? mbgl::style::VisibilityType::None
- : mbgl::style::VisibilityType::Visible);
-
- return true;
-}
-
-}
diff --git a/platform/node/src/node_style_properties.hpp b/platform/node/src/node_style_properties.hpp
deleted file mode 100644
index 0e3100207a..0000000000
--- a/platform/node/src/node_style_properties.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#include "node_style.hpp"
-
-#include <mbgl/style/layers/fill_layer.hpp>
-#include <mbgl/style/layers/line_layer.hpp>
-#include <mbgl/style/layers/symbol_layer.hpp>
-#include <mbgl/style/layers/circle_layer.hpp>
-#include <mbgl/style/layers/raster_layer.hpp>
-#include <mbgl/style/layers/background_layer.hpp>
-
-namespace node_mbgl {
-
-inline PropertySetters makeLayoutPropertySetters() {
- using namespace mbgl::style;
- PropertySetters result;
-
- result["visibility"] = &setVisibility;
-
-
- result["line-cap"] = makePropertySetter(&LineLayer::setLineCap);
- result["line-join"] = makePropertySetter(&LineLayer::setLineJoin);
- result["line-miter-limit"] = makePropertySetter(&LineLayer::setLineMiterLimit);
- result["line-round-limit"] = makePropertySetter(&LineLayer::setLineRoundLimit);
-
- result["symbol-placement"] = makePropertySetter(&SymbolLayer::setSymbolPlacement);
- result["symbol-spacing"] = makePropertySetter(&SymbolLayer::setSymbolSpacing);
- result["symbol-avoid-edges"] = makePropertySetter(&SymbolLayer::setSymbolAvoidEdges);
- result["icon-allow-overlap"] = makePropertySetter(&SymbolLayer::setIconAllowOverlap);
- result["icon-ignore-placement"] = makePropertySetter(&SymbolLayer::setIconIgnorePlacement);
- result["icon-optional"] = makePropertySetter(&SymbolLayer::setIconOptional);
- result["icon-rotation-alignment"] = makePropertySetter(&SymbolLayer::setIconRotationAlignment);
- result["icon-size"] = makePropertySetter(&SymbolLayer::setIconSize);
- result["icon-text-fit"] = makePropertySetter(&SymbolLayer::setIconTextFit);
- result["icon-text-fit-padding"] = makePropertySetter(&SymbolLayer::setIconTextFitPadding);
- result["icon-image"] = makePropertySetter(&SymbolLayer::setIconImage);
- result["icon-rotate"] = makePropertySetter(&SymbolLayer::setIconRotate);
- result["icon-padding"] = makePropertySetter(&SymbolLayer::setIconPadding);
- result["icon-keep-upright"] = makePropertySetter(&SymbolLayer::setIconKeepUpright);
- result["icon-offset"] = makePropertySetter(&SymbolLayer::setIconOffset);
- result["text-pitch-alignment"] = makePropertySetter(&SymbolLayer::setTextPitchAlignment);
- result["text-rotation-alignment"] = makePropertySetter(&SymbolLayer::setTextRotationAlignment);
- result["text-field"] = makePropertySetter(&SymbolLayer::setTextField);
- result["text-font"] = makePropertySetter(&SymbolLayer::setTextFont);
- result["text-size"] = makePropertySetter(&SymbolLayer::setTextSize);
- result["text-max-width"] = makePropertySetter(&SymbolLayer::setTextMaxWidth);
- result["text-line-height"] = makePropertySetter(&SymbolLayer::setTextLineHeight);
- result["text-letter-spacing"] = makePropertySetter(&SymbolLayer::setTextLetterSpacing);
- result["text-justify"] = makePropertySetter(&SymbolLayer::setTextJustify);
- result["text-anchor"] = makePropertySetter(&SymbolLayer::setTextAnchor);
- result["text-max-angle"] = makePropertySetter(&SymbolLayer::setTextMaxAngle);
- result["text-rotate"] = makePropertySetter(&SymbolLayer::setTextRotate);
- result["text-padding"] = makePropertySetter(&SymbolLayer::setTextPadding);
- result["text-keep-upright"] = makePropertySetter(&SymbolLayer::setTextKeepUpright);
- result["text-transform"] = makePropertySetter(&SymbolLayer::setTextTransform);
- result["text-offset"] = makePropertySetter(&SymbolLayer::setTextOffset);
- result["text-allow-overlap"] = makePropertySetter(&SymbolLayer::setTextAllowOverlap);
- result["text-ignore-placement"] = makePropertySetter(&SymbolLayer::setTextIgnorePlacement);
- result["text-optional"] = makePropertySetter(&SymbolLayer::setTextOptional);
-
-
-
-
- return result;
-}
-
-inline PropertySetters makePaintPropertySetters() {
- using namespace mbgl::style;
- PropertySetters result;
-
- result["fill-antialias"] = makePropertySetter(&FillLayer::setFillAntialias);
- result["fill-opacity"] = makePropertySetter(&FillLayer::setFillOpacity);
- result["fill-color"] = makePropertySetter(&FillLayer::setFillColor);
- result["fill-outline-color"] = makePropertySetter(&FillLayer::setFillOutlineColor);
- result["fill-translate"] = makePropertySetter(&FillLayer::setFillTranslate);
- result["fill-translate-anchor"] = makePropertySetter(&FillLayer::setFillTranslateAnchor);
- result["fill-pattern"] = makePropertySetter(&FillLayer::setFillPattern);
-
- result["line-opacity"] = makePropertySetter(&LineLayer::setLineOpacity);
- result["line-color"] = makePropertySetter(&LineLayer::setLineColor);
- result["line-translate"] = makePropertySetter(&LineLayer::setLineTranslate);
- result["line-translate-anchor"] = makePropertySetter(&LineLayer::setLineTranslateAnchor);
- result["line-width"] = makePropertySetter(&LineLayer::setLineWidth);
- result["line-gap-width"] = makePropertySetter(&LineLayer::setLineGapWidth);
- result["line-offset"] = makePropertySetter(&LineLayer::setLineOffset);
- result["line-blur"] = makePropertySetter(&LineLayer::setLineBlur);
- result["line-dasharray"] = makePropertySetter(&LineLayer::setLineDasharray);
- result["line-pattern"] = makePropertySetter(&LineLayer::setLinePattern);
-
- result["icon-opacity"] = makePropertySetter(&SymbolLayer::setIconOpacity);
- result["icon-color"] = makePropertySetter(&SymbolLayer::setIconColor);
- result["icon-halo-color"] = makePropertySetter(&SymbolLayer::setIconHaloColor);
- result["icon-halo-width"] = makePropertySetter(&SymbolLayer::setIconHaloWidth);
- result["icon-halo-blur"] = makePropertySetter(&SymbolLayer::setIconHaloBlur);
- result["icon-translate"] = makePropertySetter(&SymbolLayer::setIconTranslate);
- result["icon-translate-anchor"] = makePropertySetter(&SymbolLayer::setIconTranslateAnchor);
- result["text-opacity"] = makePropertySetter(&SymbolLayer::setTextOpacity);
- result["text-color"] = makePropertySetter(&SymbolLayer::setTextColor);
- result["text-halo-color"] = makePropertySetter(&SymbolLayer::setTextHaloColor);
- result["text-halo-width"] = makePropertySetter(&SymbolLayer::setTextHaloWidth);
- result["text-halo-blur"] = makePropertySetter(&SymbolLayer::setTextHaloBlur);
- result["text-translate"] = makePropertySetter(&SymbolLayer::setTextTranslate);
- result["text-translate-anchor"] = makePropertySetter(&SymbolLayer::setTextTranslateAnchor);
-
- result["circle-radius"] = makePropertySetter(&CircleLayer::setCircleRadius);
- result["circle-color"] = makePropertySetter(&CircleLayer::setCircleColor);
- result["circle-blur"] = makePropertySetter(&CircleLayer::setCircleBlur);
- result["circle-opacity"] = makePropertySetter(&CircleLayer::setCircleOpacity);
- result["circle-translate"] = makePropertySetter(&CircleLayer::setCircleTranslate);
- result["circle-translate-anchor"] = makePropertySetter(&CircleLayer::setCircleTranslateAnchor);
-
- result["raster-opacity"] = makePropertySetter(&RasterLayer::setRasterOpacity);
- result["raster-hue-rotate"] = makePropertySetter(&RasterLayer::setRasterHueRotate);
- result["raster-brightness-min"] = makePropertySetter(&RasterLayer::setRasterBrightnessMin);
- result["raster-brightness-max"] = makePropertySetter(&RasterLayer::setRasterBrightnessMax);
- result["raster-saturation"] = makePropertySetter(&RasterLayer::setRasterSaturation);
- result["raster-contrast"] = makePropertySetter(&RasterLayer::setRasterContrast);
- result["raster-fade-duration"] = makePropertySetter(&RasterLayer::setRasterFadeDuration);
-
- result["background-color"] = makePropertySetter(&BackgroundLayer::setBackgroundColor);
- result["background-pattern"] = makePropertySetter(&BackgroundLayer::setBackgroundPattern);
- result["background-opacity"] = makePropertySetter(&BackgroundLayer::setBackgroundOpacity);
-
- return result;
-}
-
-inline bool setFilter(mbgl::style::Layer& layer, const mbgl::style::Filter& filter) {
- using namespace mbgl::style;
-
- if (layer.is<FillLayer>()) {
- layer.as<FillLayer>()->setFilter(filter);
- return true;
- }
- if (layer.is<LineLayer>()) {
- layer.as<LineLayer>()->setFilter(filter);
- return true;
- }
- if (layer.is<SymbolLayer>()) {
- layer.as<SymbolLayer>()->setFilter(filter);
- return true;
- }
- if (layer.is<CircleLayer>()) {
- layer.as<CircleLayer>()->setFilter(filter);
- return true;
- }
-
- Nan::ThrowTypeError("layer doesn't support filters");
- return false;
-}
-
-}
diff --git a/platform/node/src/node_style_properties.hpp.ejs b/platform/node/src/node_style_properties.hpp.ejs
deleted file mode 100644
index bfd3f74ca5..0000000000
--- a/platform/node/src/node_style_properties.hpp.ejs
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "node_style.hpp"
-
-<% for (const layer of locals.layers) { -%>
-#include <mbgl/style/layers/<%- layer.type %>_layer.hpp>
-<% } -%>
-
-namespace node_mbgl {
-
-inline PropertySetters makeLayoutPropertySetters() {
- using namespace mbgl::style;
- PropertySetters result;
-
- result["visibility"] = &setVisibility;
-
-<% for (const layer of locals.layers) { -%>
-<% for (const property of layer.layoutProperties) { -%>
- result["<%- property.name %>"] = makePropertySetter(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
-<% } -%>
-
-<% } -%>
- return result;
-}
-
-inline PropertySetters makePaintPropertySetters() {
- using namespace mbgl::style;
- PropertySetters result;
-
-<% for (const layer of locals.layers) { -%>
-<% for (const property of layer.paintProperties) { -%>
- result["<%- property.name %>"] = makePropertySetter(&<%- camelize(layer.type) %>Layer::set<%- camelize(property.name) %>);
-<% } -%>
-
-<% } -%>
- return result;
-}
-
-inline bool setFilter(mbgl::style::Layer& layer, const mbgl::style::Filter& filter) {
- using namespace mbgl::style;
-
-<% for (const layer of locals.layers) { -%>
-<% if (layer.type !== 'raster' && layer.type !== 'background' && layer.type !== 'custom') { -%>
- if (layer.is<<%- camelize(layer.type) %>Layer>()) {
- layer.as<<%- camelize(layer.type) %>Layer>()->setFilter(filter);
- return true;
- }
-<% } -%>
-<% } -%>
-
- Nan::ThrowTypeError("layer doesn't support filters");
- return false;
-}
-
-}
diff --git a/scripts/generate-style-code.js b/scripts/generate-style-code.js
index 7859c65a0e..642da1174b 100644
--- a/scripts/generate-style-code.js
+++ b/scripts/generate-style-code.js
@@ -111,5 +111,5 @@ for (const layer of layers) {
fs.writeFileSync(`src/mbgl/style/layers/${layer.type}_layer_properties.cpp`, propertiesCpp(layer));
}
-const nodeStyleCpp = ejs.compile(fs.readFileSync('platform/node/src/node_style_properties.hpp.ejs', 'utf8'), {strict: true});
-fs.writeFileSync('platform/node/src/node_style_properties.hpp', nodeStyleCpp({layers: layers}));
+const propertySettersHpp = ejs.compile(fs.readFileSync('include/mbgl/style/conversion/make_property_setters.hpp.ejs', 'utf8'), {strict: true});
+fs.writeFileSync('include/mbgl/style/conversion/make_property_setters.hpp', propertySettersHpp({layers: layers}));
diff --git a/src/mbgl/style/layer_impl.hpp b/src/mbgl/style/layer_impl.hpp
index 33ad2e32ac..d2bf866e8e 100644
--- a/src/mbgl/style/layer_impl.hpp
+++ b/src/mbgl/style/layer_impl.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/filter.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/rapidjson.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <memory>
@@ -46,8 +45,8 @@ public:
// Create an identical copy of this layer.
virtual std::unique_ptr<Layer> clone() const = 0;
- virtual void parseLayout(const JSValue& value) = 0;
- virtual void parsePaints(const JSValue& value) = 0;
+ // Create a layer, copying all properties except id, ref, and paint properties from this layer.
+ virtual std::unique_ptr<Layer> cloneRef(const std::string& id) const = 0;
// If the layer has a ref, the ref. Otherwise, the id.
const std::string& bucketName() const;
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index aeb4067503..42cd76d01f 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -23,6 +23,14 @@ std::unique_ptr<Layer> BackgroundLayer::Impl::clone() const {
return std::make_unique<BackgroundLayer>(*this);
}
+std::unique_ptr<Layer> BackgroundLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<BackgroundLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = BackgroundPaintProperties();
+ return std::move(result);
+}
+
// Layout properties
@@ -33,24 +41,24 @@ PropertyValue<Color> BackgroundLayer::getBackgroundColor() const {
return impl->paint.backgroundColor.get();
}
-void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value) {
- impl->paint.backgroundColor.set(value);
+void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.backgroundColor.set(value, klass);
}
PropertyValue<std::string> BackgroundLayer::getBackgroundPattern() const {
return impl->paint.backgroundPattern.get();
}
-void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value) {
- impl->paint.backgroundPattern.set(value);
+void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+ impl->paint.backgroundPattern.set(value, klass);
}
PropertyValue<float> BackgroundLayer::getBackgroundOpacity() const {
return impl->paint.backgroundOpacity.get();
}
-void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value) {
- impl->paint.backgroundOpacity.set(value);
+void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.backgroundOpacity.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/background_layer_impl.cpp b/src/mbgl/style/layers/background_layer_impl.cpp
index 0c09c5d158..ea389b828e 100644
--- a/src/mbgl/style/layers/background_layer_impl.cpp
+++ b/src/mbgl/style/layers/background_layer_impl.cpp
@@ -4,10 +4,6 @@
namespace mbgl {
namespace style {
-void BackgroundLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void BackgroundLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/background_layer_impl.hpp b/src/mbgl/style/layers/background_layer_impl.hpp
index 19e2a062a4..abbb740f42 100644
--- a/src/mbgl/style/layers/background_layer_impl.hpp
+++ b/src/mbgl/style/layers/background_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
class BackgroundLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override {};
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/background_layer_properties.cpp b/src/mbgl/style/layers/background_layer_properties.cpp
index a20cedf12c..558093a255 100644
--- a/src/mbgl/style/layers/background_layer_properties.cpp
+++ b/src/mbgl/style/layers/background_layer_properties.cpp
@@ -5,12 +5,6 @@
namespace mbgl {
namespace style {
-void BackgroundPaintProperties::parse(const JSValue& value) {
- backgroundColor.parse("background-color", value);
- backgroundPattern.parse("background-pattern", value);
- backgroundOpacity.parse("background-opacity", value);
-}
-
void BackgroundPaintProperties::cascade(const CascadeParameters& parameters) {
backgroundColor.cascade(parameters);
backgroundPattern.cascade(parameters);
diff --git a/src/mbgl/style/layers/background_layer_properties.hpp b/src/mbgl/style/layers/background_layer_properties.hpp
index 88a2ef1478..6c5a7c57ca 100644
--- a/src/mbgl/style/layers/background_layer_properties.hpp
+++ b/src/mbgl/style/layers/background_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class BackgroundPaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 8066d7fd3c..a47d723548 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> CircleLayer::Impl::clone() const {
return std::make_unique<CircleLayer>(*this);
}
+std::unique_ptr<Layer> CircleLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<CircleLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = CirclePaintProperties();
+ return std::move(result);
+}
+
// Source
const std::string& CircleLayer::getSourceID() const {
@@ -57,48 +65,48 @@ PropertyValue<float> CircleLayer::getCircleRadius() const {
return impl->paint.circleRadius.get();
}
-void CircleLayer::setCircleRadius(PropertyValue<float> value) {
- impl->paint.circleRadius.set(value);
+void CircleLayer::setCircleRadius(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.circleRadius.set(value, klass);
}
PropertyValue<Color> CircleLayer::getCircleColor() const {
return impl->paint.circleColor.get();
}
-void CircleLayer::setCircleColor(PropertyValue<Color> value) {
- impl->paint.circleColor.set(value);
+void CircleLayer::setCircleColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.circleColor.set(value, klass);
}
PropertyValue<float> CircleLayer::getCircleBlur() const {
return impl->paint.circleBlur.get();
}
-void CircleLayer::setCircleBlur(PropertyValue<float> value) {
- impl->paint.circleBlur.set(value);
+void CircleLayer::setCircleBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.circleBlur.set(value, klass);
}
PropertyValue<float> CircleLayer::getCircleOpacity() const {
return impl->paint.circleOpacity.get();
}
-void CircleLayer::setCircleOpacity(PropertyValue<float> value) {
- impl->paint.circleOpacity.set(value);
+void CircleLayer::setCircleOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.circleOpacity.set(value, klass);
}
PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate() const {
return impl->paint.circleTranslate.get();
}
-void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value) {
- impl->paint.circleTranslate.set(value);
+void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+ impl->paint.circleTranslate.set(value, klass);
}
PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor() const {
return impl->paint.circleTranslateAnchor.get();
}
-void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
- impl->paint.circleTranslateAnchor.set(value);
+void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+ impl->paint.circleTranslateAnchor.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/circle_layer_impl.cpp b/src/mbgl/style/layers/circle_layer_impl.cpp
index d64759e743..e08d9df146 100644
--- a/src/mbgl/style/layers/circle_layer_impl.cpp
+++ b/src/mbgl/style/layers/circle_layer_impl.cpp
@@ -8,10 +8,6 @@
namespace mbgl {
namespace style {
-void CircleLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void CircleLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/circle_layer_impl.hpp b/src/mbgl/style/layers/circle_layer_impl.hpp
index 463f3ca18d..555691b6b4 100644
--- a/src/mbgl/style/layers/circle_layer_impl.hpp
+++ b/src/mbgl/style/layers/circle_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
class CircleLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override {};
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/circle_layer_properties.cpp b/src/mbgl/style/layers/circle_layer_properties.cpp
index b21df1e2d0..045c73ba63 100644
--- a/src/mbgl/style/layers/circle_layer_properties.cpp
+++ b/src/mbgl/style/layers/circle_layer_properties.cpp
@@ -5,15 +5,6 @@
namespace mbgl {
namespace style {
-void CirclePaintProperties::parse(const JSValue& value) {
- circleRadius.parse("circle-radius", value);
- circleColor.parse("circle-color", value);
- circleBlur.parse("circle-blur", value);
- circleOpacity.parse("circle-opacity", value);
- circleTranslate.parse("circle-translate", value);
- circleTranslateAnchor.parse("circle-translate-anchor", value);
-}
-
void CirclePaintProperties::cascade(const CascadeParameters& parameters) {
circleRadius.cascade(parameters);
circleColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/circle_layer_properties.hpp b/src/mbgl/style/layers/circle_layer_properties.hpp
index 87091e7b59..40d37dc392 100644
--- a/src/mbgl/style/layers/circle_layer_properties.hpp
+++ b/src/mbgl/style/layers/circle_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class CirclePaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/custom_layer_impl.cpp b/src/mbgl/style/layers/custom_layer_impl.cpp
index 214d4ce663..a0686e353c 100644
--- a/src/mbgl/style/layers/custom_layer_impl.cpp
+++ b/src/mbgl/style/layers/custom_layer_impl.cpp
@@ -33,6 +33,11 @@ std::unique_ptr<Layer> CustomLayer::Impl::clone() const {
return std::make_unique<CustomLayer>(*this);
}
+std::unique_ptr<Layer> CustomLayer::Impl::cloneRef(const std::string&) const {
+ assert(false);
+ return std::make_unique<CustomLayer>(*this);
+}
+
void CustomLayer::Impl::initialize() {
assert(initializeFn);
initializeFn(context);
diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp
index 00e576b6a3..ffa892ddf8 100644
--- a/src/mbgl/style/layers/custom_layer_impl.hpp
+++ b/src/mbgl/style/layers/custom_layer_impl.hpp
@@ -25,9 +25,7 @@ public:
private:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) final {}
- void parsePaints(const JSValue&) final {}
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) final {}
bool recalculate(const CalculationParameters&) final;
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 7d7d1a9e27..44894aff33 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> FillLayer::Impl::clone() const {
return std::make_unique<FillLayer>(*this);
}
+std::unique_ptr<Layer> FillLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<FillLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = FillPaintProperties();
+ return std::move(result);
+}
+
// Source
const std::string& FillLayer::getSourceID() const {
@@ -57,56 +65,56 @@ PropertyValue<bool> FillLayer::getFillAntialias() const {
return impl->paint.fillAntialias.get();
}
-void FillLayer::setFillAntialias(PropertyValue<bool> value) {
- impl->paint.fillAntialias.set(value);
+void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) {
+ impl->paint.fillAntialias.set(value, klass);
}
PropertyValue<float> FillLayer::getFillOpacity() const {
return impl->paint.fillOpacity.get();
}
-void FillLayer::setFillOpacity(PropertyValue<float> value) {
- impl->paint.fillOpacity.set(value);
+void FillLayer::setFillOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.fillOpacity.set(value, klass);
}
PropertyValue<Color> FillLayer::getFillColor() const {
return impl->paint.fillColor.get();
}
-void FillLayer::setFillColor(PropertyValue<Color> value) {
- impl->paint.fillColor.set(value);
+void FillLayer::setFillColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.fillColor.set(value, klass);
}
PropertyValue<Color> FillLayer::getFillOutlineColor() const {
return impl->paint.fillOutlineColor.get();
}
-void FillLayer::setFillOutlineColor(PropertyValue<Color> value) {
- impl->paint.fillOutlineColor.set(value);
+void FillLayer::setFillOutlineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.fillOutlineColor.set(value, klass);
}
PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate() const {
return impl->paint.fillTranslate.get();
}
-void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value) {
- impl->paint.fillTranslate.set(value);
+void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+ impl->paint.fillTranslate.set(value, klass);
}
PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor() const {
return impl->paint.fillTranslateAnchor.get();
}
-void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
- impl->paint.fillTranslateAnchor.set(value);
+void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+ impl->paint.fillTranslateAnchor.set(value, klass);
}
PropertyValue<std::string> FillLayer::getFillPattern() const {
return impl->paint.fillPattern.get();
}
-void FillLayer::setFillPattern(PropertyValue<std::string> value) {
- impl->paint.fillPattern.set(value);
+void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+ impl->paint.fillPattern.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/fill_layer_impl.cpp b/src/mbgl/style/layers/fill_layer_impl.cpp
index 3d847127c9..2992312514 100644
--- a/src/mbgl/style/layers/fill_layer_impl.cpp
+++ b/src/mbgl/style/layers/fill_layer_impl.cpp
@@ -8,10 +8,6 @@
namespace mbgl {
namespace style {
-void FillLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void FillLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/fill_layer_impl.hpp b/src/mbgl/style/layers/fill_layer_impl.hpp
index a37dd76ace..fc6578ecd1 100644
--- a/src/mbgl/style/layers/fill_layer_impl.hpp
+++ b/src/mbgl/style/layers/fill_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
class FillLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override {};
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/fill_layer_properties.cpp b/src/mbgl/style/layers/fill_layer_properties.cpp
index a4714689f9..9a55cbc145 100644
--- a/src/mbgl/style/layers/fill_layer_properties.cpp
+++ b/src/mbgl/style/layers/fill_layer_properties.cpp
@@ -5,16 +5,6 @@
namespace mbgl {
namespace style {
-void FillPaintProperties::parse(const JSValue& value) {
- fillAntialias.parse("fill-antialias", value);
- fillOpacity.parse("fill-opacity", value);
- fillColor.parse("fill-color", value);
- fillOutlineColor.parse("fill-outline-color", value);
- fillTranslate.parse("fill-translate", value);
- fillTranslateAnchor.parse("fill-translate-anchor", value);
- fillPattern.parse("fill-pattern", value);
-}
-
void FillPaintProperties::cascade(const CascadeParameters& parameters) {
fillAntialias.cascade(parameters);
fillOpacity.cascade(parameters);
diff --git a/src/mbgl/style/layers/fill_layer_properties.hpp b/src/mbgl/style/layers/fill_layer_properties.hpp
index fb60b90258..82981a9b64 100644
--- a/src/mbgl/style/layers/fill_layer_properties.hpp
+++ b/src/mbgl/style/layers/fill_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class FillPaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 4f78d6b55e..017691c8ec 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -37,6 +37,14 @@ std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::clone() const {
return std::make_unique<<%- camelize(type) %>Layer>(*this);
}
+std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<<%- camelize(type) %>Layer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = <%- camelize(type) %>PaintProperties();
+ return std::move(result);
+}
+
<% if (type !== 'background') { -%>
// Source
@@ -83,8 +91,8 @@ PropertyValue<<%- propertyType(property) %>> <%- camelize(type) %>Layer::get<%-
return impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.get();
}
-void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>> value) {
- impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.set(value);
+void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>> value, const optional<std::string>& klass) {
+ impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.set(value, klass);
}
<% } -%>
diff --git a/src/mbgl/style/layers/layer_properties.cpp.ejs b/src/mbgl/style/layers/layer_properties.cpp.ejs
index 8fef8d29c4..b781a4a9d9 100644
--- a/src/mbgl/style/layers/layer_properties.cpp.ejs
+++ b/src/mbgl/style/layers/layer_properties.cpp.ejs
@@ -11,12 +11,6 @@ namespace mbgl {
namespace style {
<% if (layoutProperties.length) { -%>
-void <%- camelize(type) %>LayoutProperties::parse(const JSValue& value) {
-<% for (const property of layoutProperties) { -%>
- <%- camelizeWithLeadingLowercase(property.name) %>.parse(<%- JSON.stringify(property.name) %>, value);
-<% } -%>
-}
-
void <%- camelize(type) %>LayoutProperties::recalculate(const CalculationParameters& parameters) {
<% for (const property of layoutProperties) { -%>
<%- camelizeWithLeadingLowercase(property.name) %>.calculate(parameters);
@@ -24,12 +18,6 @@ void <%- camelize(type) %>LayoutProperties::recalculate(const CalculationParamet
}
<% } -%>
-void <%- camelize(type) %>PaintProperties::parse(const JSValue& value) {
-<% for (const property of paintProperties) { -%>
- <%- camelizeWithLeadingLowercase(property.name) %>.parse(<%- JSON.stringify(property.name) %>, value);
-<% } -%>
-}
-
void <%- camelize(type) %>PaintProperties::cascade(const CascadeParameters& parameters) {
<% for (const property of paintProperties) { -%>
<%- camelizeWithLeadingLowercase(property.name) %>.cascade(parameters);
diff --git a/src/mbgl/style/layers/layer_properties.hpp.ejs b/src/mbgl/style/layers/layer_properties.hpp.ejs
index 60f40efa8e..a485621ac6 100644
--- a/src/mbgl/style/layers/layer_properties.hpp.ejs
+++ b/src/mbgl/style/layers/layer_properties.hpp.ejs
@@ -10,7 +10,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -21,7 +20,6 @@ class CalculationParameters;
<% if (layoutProperties.length) { -%>
class <%- camelize(type) %>LayoutProperties {
public:
- void parse(const JSValue&);
void recalculate(const CalculationParameters&);
<% for (const property of layoutProperties) { -%>
@@ -32,7 +30,6 @@ public:
<% } -%>
class <%- camelize(type) %>PaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index e720d1fcfb..3ad72cda16 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> LineLayer::Impl::clone() const {
return std::make_unique<LineLayer>(*this);
}
+std::unique_ptr<Layer> LineLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<LineLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = LinePaintProperties();
+ return std::move(result);
+}
+
// Source
const std::string& LineLayer::getSourceID() const {
@@ -85,80 +93,80 @@ PropertyValue<float> LineLayer::getLineOpacity() const {
return impl->paint.lineOpacity.get();
}
-void LineLayer::setLineOpacity(PropertyValue<float> value) {
- impl->paint.lineOpacity.set(value);
+void LineLayer::setLineOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.lineOpacity.set(value, klass);
}
PropertyValue<Color> LineLayer::getLineColor() const {
return impl->paint.lineColor.get();
}
-void LineLayer::setLineColor(PropertyValue<Color> value) {
- impl->paint.lineColor.set(value);
+void LineLayer::setLineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.lineColor.set(value, klass);
}
PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate() const {
return impl->paint.lineTranslate.get();
}
-void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value) {
- impl->paint.lineTranslate.set(value);
+void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+ impl->paint.lineTranslate.set(value, klass);
}
PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor() const {
return impl->paint.lineTranslateAnchor.get();
}
-void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
- impl->paint.lineTranslateAnchor.set(value);
+void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+ impl->paint.lineTranslateAnchor.set(value, klass);
}
PropertyValue<float> LineLayer::getLineWidth() const {
return impl->paint.lineWidth.get();
}
-void LineLayer::setLineWidth(PropertyValue<float> value) {
- impl->paint.lineWidth.set(value);
+void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.lineWidth.set(value, klass);
}
PropertyValue<float> LineLayer::getLineGapWidth() const {
return impl->paint.lineGapWidth.get();
}
-void LineLayer::setLineGapWidth(PropertyValue<float> value) {
- impl->paint.lineGapWidth.set(value);
+void LineLayer::setLineGapWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.lineGapWidth.set(value, klass);
}
PropertyValue<float> LineLayer::getLineOffset() const {
return impl->paint.lineOffset.get();
}
-void LineLayer::setLineOffset(PropertyValue<float> value) {
- impl->paint.lineOffset.set(value);
+void LineLayer::setLineOffset(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.lineOffset.set(value, klass);
}
PropertyValue<float> LineLayer::getLineBlur() const {
return impl->paint.lineBlur.get();
}
-void LineLayer::setLineBlur(PropertyValue<float> value) {
- impl->paint.lineBlur.set(value);
+void LineLayer::setLineBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.lineBlur.set(value, klass);
}
PropertyValue<std::vector<float>> LineLayer::getLineDasharray() const {
return impl->paint.lineDasharray.get();
}
-void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value) {
- impl->paint.lineDasharray.set(value);
+void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) {
+ impl->paint.lineDasharray.set(value, klass);
}
PropertyValue<std::string> LineLayer::getLinePattern() const {
return impl->paint.linePattern.get();
}
-void LineLayer::setLinePattern(PropertyValue<std::string> value) {
- impl->paint.linePattern.set(value);
+void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
+ impl->paint.linePattern.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/line_layer_impl.cpp b/src/mbgl/style/layers/line_layer_impl.cpp
index 589b129ee6..3cdd90b7fd 100644
--- a/src/mbgl/style/layers/line_layer_impl.cpp
+++ b/src/mbgl/style/layers/line_layer_impl.cpp
@@ -8,14 +8,6 @@
namespace mbgl {
namespace style {
-void LineLayer::Impl::parseLayout(const JSValue& value) {
- layout.parse(value);
-}
-
-void LineLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void LineLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/line_layer_impl.hpp b/src/mbgl/style/layers/line_layer_impl.hpp
index 3356dc2ceb..e130bc01bc 100644
--- a/src/mbgl/style/layers/line_layer_impl.hpp
+++ b/src/mbgl/style/layers/line_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
class LineLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override;
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/line_layer_properties.cpp b/src/mbgl/style/layers/line_layer_properties.cpp
index 7c74f6de04..2d6092745e 100644
--- a/src/mbgl/style/layers/line_layer_properties.cpp
+++ b/src/mbgl/style/layers/line_layer_properties.cpp
@@ -5,13 +5,6 @@
namespace mbgl {
namespace style {
-void LineLayoutProperties::parse(const JSValue& value) {
- lineCap.parse("line-cap", value);
- lineJoin.parse("line-join", value);
- lineMiterLimit.parse("line-miter-limit", value);
- lineRoundLimit.parse("line-round-limit", value);
-}
-
void LineLayoutProperties::recalculate(const CalculationParameters& parameters) {
lineCap.calculate(parameters);
lineJoin.calculate(parameters);
@@ -19,19 +12,6 @@ void LineLayoutProperties::recalculate(const CalculationParameters& parameters)
lineRoundLimit.calculate(parameters);
}
-void LinePaintProperties::parse(const JSValue& value) {
- lineOpacity.parse("line-opacity", value);
- lineColor.parse("line-color", value);
- lineTranslate.parse("line-translate", value);
- lineTranslateAnchor.parse("line-translate-anchor", value);
- lineWidth.parse("line-width", value);
- lineGapWidth.parse("line-gap-width", value);
- lineOffset.parse("line-offset", value);
- lineBlur.parse("line-blur", value);
- lineDasharray.parse("line-dasharray", value);
- linePattern.parse("line-pattern", value);
-}
-
void LinePaintProperties::cascade(const CascadeParameters& parameters) {
lineOpacity.cascade(parameters);
lineColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/line_layer_properties.hpp b/src/mbgl/style/layers/line_layer_properties.hpp
index 0bc08f1988..e7dbddf442 100644
--- a/src/mbgl/style/layers/line_layer_properties.hpp
+++ b/src/mbgl/style/layers/line_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class LineLayoutProperties {
public:
- void parse(const JSValue&);
void recalculate(const CalculationParameters&);
LayoutProperty<LineCapType> lineCap { LineCapType::Butt };
@@ -26,7 +24,6 @@ public:
class LinePaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index cdba19ac4e..d4e121babe 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> RasterLayer::Impl::clone() const {
return std::make_unique<RasterLayer>(*this);
}
+std::unique_ptr<Layer> RasterLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<RasterLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = RasterPaintProperties();
+ return std::move(result);
+}
+
// Source
const std::string& RasterLayer::getSourceID() const {
@@ -40,56 +48,56 @@ PropertyValue<float> RasterLayer::getRasterOpacity() const {
return impl->paint.rasterOpacity.get();
}
-void RasterLayer::setRasterOpacity(PropertyValue<float> value) {
- impl->paint.rasterOpacity.set(value);
+void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterOpacity.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterHueRotate() const {
return impl->paint.rasterHueRotate.get();
}
-void RasterLayer::setRasterHueRotate(PropertyValue<float> value) {
- impl->paint.rasterHueRotate.set(value);
+void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterHueRotate.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterBrightnessMin() const {
return impl->paint.rasterBrightnessMin.get();
}
-void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value) {
- impl->paint.rasterBrightnessMin.set(value);
+void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterBrightnessMin.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterBrightnessMax() const {
return impl->paint.rasterBrightnessMax.get();
}
-void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value) {
- impl->paint.rasterBrightnessMax.set(value);
+void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterBrightnessMax.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterSaturation() const {
return impl->paint.rasterSaturation.get();
}
-void RasterLayer::setRasterSaturation(PropertyValue<float> value) {
- impl->paint.rasterSaturation.set(value);
+void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterSaturation.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterContrast() const {
return impl->paint.rasterContrast.get();
}
-void RasterLayer::setRasterContrast(PropertyValue<float> value) {
- impl->paint.rasterContrast.set(value);
+void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterContrast.set(value, klass);
}
PropertyValue<float> RasterLayer::getRasterFadeDuration() const {
return impl->paint.rasterFadeDuration.get();
}
-void RasterLayer::setRasterFadeDuration(PropertyValue<float> value) {
- impl->paint.rasterFadeDuration.set(value);
+void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.rasterFadeDuration.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/raster_layer_impl.cpp b/src/mbgl/style/layers/raster_layer_impl.cpp
index 4854ec041d..879bfa4559 100644
--- a/src/mbgl/style/layers/raster_layer_impl.cpp
+++ b/src/mbgl/style/layers/raster_layer_impl.cpp
@@ -4,10 +4,6 @@
namespace mbgl {
namespace style {
-void RasterLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void RasterLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/raster_layer_impl.hpp b/src/mbgl/style/layers/raster_layer_impl.hpp
index 6812b469a6..a5b396e2ed 100644
--- a/src/mbgl/style/layers/raster_layer_impl.hpp
+++ b/src/mbgl/style/layers/raster_layer_impl.hpp
@@ -10,9 +10,7 @@ namespace style {
class RasterLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override {};
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/raster_layer_properties.cpp b/src/mbgl/style/layers/raster_layer_properties.cpp
index 0e6afc5e9c..68d9d1d35d 100644
--- a/src/mbgl/style/layers/raster_layer_properties.cpp
+++ b/src/mbgl/style/layers/raster_layer_properties.cpp
@@ -5,16 +5,6 @@
namespace mbgl {
namespace style {
-void RasterPaintProperties::parse(const JSValue& value) {
- rasterOpacity.parse("raster-opacity", value);
- rasterHueRotate.parse("raster-hue-rotate", value);
- rasterBrightnessMin.parse("raster-brightness-min", value);
- rasterBrightnessMax.parse("raster-brightness-max", value);
- rasterSaturation.parse("raster-saturation", value);
- rasterContrast.parse("raster-contrast", value);
- rasterFadeDuration.parse("raster-fade-duration", value);
-}
-
void RasterPaintProperties::cascade(const CascadeParameters& parameters) {
rasterOpacity.cascade(parameters);
rasterHueRotate.cascade(parameters);
diff --git a/src/mbgl/style/layers/raster_layer_properties.hpp b/src/mbgl/style/layers/raster_layer_properties.hpp
index 1581ca6687..ddfb833e12 100644
--- a/src/mbgl/style/layers/raster_layer_properties.hpp
+++ b/src/mbgl/style/layers/raster_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class RasterPaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 905caa0310..c26123f0ec 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -24,6 +24,14 @@ std::unique_ptr<Layer> SymbolLayer::Impl::clone() const {
return std::make_unique<SymbolLayer>(*this);
}
+std::unique_ptr<Layer> SymbolLayer::Impl::cloneRef(const std::string& id_) const {
+ auto result = std::make_unique<SymbolLayer>(*this);
+ result->impl->id = id_;
+ result->impl->ref = this->id;
+ result->impl->paint = SymbolPaintProperties();
+ return std::move(result);
+}
+
// Source
const std::string& SymbolLayer::getSourceID() const {
@@ -295,112 +303,112 @@ PropertyValue<float> SymbolLayer::getIconOpacity() const {
return impl->paint.iconOpacity.get();
}
-void SymbolLayer::setIconOpacity(PropertyValue<float> value) {
- impl->paint.iconOpacity.set(value);
+void SymbolLayer::setIconOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.iconOpacity.set(value, klass);
}
PropertyValue<Color> SymbolLayer::getIconColor() const {
return impl->paint.iconColor.get();
}
-void SymbolLayer::setIconColor(PropertyValue<Color> value) {
- impl->paint.iconColor.set(value);
+void SymbolLayer::setIconColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.iconColor.set(value, klass);
}
PropertyValue<Color> SymbolLayer::getIconHaloColor() const {
return impl->paint.iconHaloColor.get();
}
-void SymbolLayer::setIconHaloColor(PropertyValue<Color> value) {
- impl->paint.iconHaloColor.set(value);
+void SymbolLayer::setIconHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.iconHaloColor.set(value, klass);
}
PropertyValue<float> SymbolLayer::getIconHaloWidth() const {
return impl->paint.iconHaloWidth.get();
}
-void SymbolLayer::setIconHaloWidth(PropertyValue<float> value) {
- impl->paint.iconHaloWidth.set(value);
+void SymbolLayer::setIconHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.iconHaloWidth.set(value, klass);
}
PropertyValue<float> SymbolLayer::getIconHaloBlur() const {
return impl->paint.iconHaloBlur.get();
}
-void SymbolLayer::setIconHaloBlur(PropertyValue<float> value) {
- impl->paint.iconHaloBlur.set(value);
+void SymbolLayer::setIconHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.iconHaloBlur.set(value, klass);
}
PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate() const {
return impl->paint.iconTranslate.get();
}
-void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value) {
- impl->paint.iconTranslate.set(value);
+void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+ impl->paint.iconTranslate.set(value, klass);
}
PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor() const {
return impl->paint.iconTranslateAnchor.get();
}
-void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
- impl->paint.iconTranslateAnchor.set(value);
+void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+ impl->paint.iconTranslateAnchor.set(value, klass);
}
PropertyValue<float> SymbolLayer::getTextOpacity() const {
return impl->paint.textOpacity.get();
}
-void SymbolLayer::setTextOpacity(PropertyValue<float> value) {
- impl->paint.textOpacity.set(value);
+void SymbolLayer::setTextOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.textOpacity.set(value, klass);
}
PropertyValue<Color> SymbolLayer::getTextColor() const {
return impl->paint.textColor.get();
}
-void SymbolLayer::setTextColor(PropertyValue<Color> value) {
- impl->paint.textColor.set(value);
+void SymbolLayer::setTextColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.textColor.set(value, klass);
}
PropertyValue<Color> SymbolLayer::getTextHaloColor() const {
return impl->paint.textHaloColor.get();
}
-void SymbolLayer::setTextHaloColor(PropertyValue<Color> value) {
- impl->paint.textHaloColor.set(value);
+void SymbolLayer::setTextHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
+ impl->paint.textHaloColor.set(value, klass);
}
PropertyValue<float> SymbolLayer::getTextHaloWidth() const {
return impl->paint.textHaloWidth.get();
}
-void SymbolLayer::setTextHaloWidth(PropertyValue<float> value) {
- impl->paint.textHaloWidth.set(value);
+void SymbolLayer::setTextHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.textHaloWidth.set(value, klass);
}
PropertyValue<float> SymbolLayer::getTextHaloBlur() const {
return impl->paint.textHaloBlur.get();
}
-void SymbolLayer::setTextHaloBlur(PropertyValue<float> value) {
- impl->paint.textHaloBlur.set(value);
+void SymbolLayer::setTextHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
+ impl->paint.textHaloBlur.set(value, klass);
}
PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate() const {
return impl->paint.textTranslate.get();
}
-void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value) {
- impl->paint.textTranslate.set(value);
+void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
+ impl->paint.textTranslate.set(value, klass);
}
PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor() const {
return impl->paint.textTranslateAnchor.get();
}
-void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
- impl->paint.textTranslateAnchor.set(value);
+void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
+ impl->paint.textTranslateAnchor.set(value, klass);
}
} // namespace style
diff --git a/src/mbgl/style/layers/symbol_layer_impl.cpp b/src/mbgl/style/layers/symbol_layer_impl.cpp
index eeceb52078..0243b1dfa5 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.cpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.cpp
@@ -5,14 +5,6 @@
namespace mbgl {
namespace style {
-void SymbolLayer::Impl::parseLayout(const JSValue& value) {
- layout.parse(value);
-}
-
-void SymbolLayer::Impl::parsePaints(const JSValue& layer) {
- paint.parse(layer);
-}
-
void SymbolLayer::Impl::cascade(const CascadeParameters& parameters) {
paint.cascade(parameters);
}
diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp
index 9727cc6480..7765d6790e 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.hpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.hpp
@@ -13,9 +13,7 @@ namespace style {
class SymbolLayer::Impl : public Layer::Impl {
public:
std::unique_ptr<Layer> clone() const override;
-
- void parseLayout(const JSValue&) override;
- void parsePaints(const JSValue&) override;
+ std::unique_ptr<Layer> cloneRef(const std::string& id) const override;
void cascade(const CascadeParameters&) override;
bool recalculate(const CalculationParameters&) override;
diff --git a/src/mbgl/style/layers/symbol_layer_properties.cpp b/src/mbgl/style/layers/symbol_layer_properties.cpp
index d77d10700c..59a73d3d59 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.cpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.cpp
@@ -5,43 +5,6 @@
namespace mbgl {
namespace style {
-void SymbolLayoutProperties::parse(const JSValue& value) {
- symbolPlacement.parse("symbol-placement", value);
- symbolSpacing.parse("symbol-spacing", value);
- symbolAvoidEdges.parse("symbol-avoid-edges", value);
- iconAllowOverlap.parse("icon-allow-overlap", value);
- iconIgnorePlacement.parse("icon-ignore-placement", value);
- iconOptional.parse("icon-optional", value);
- iconRotationAlignment.parse("icon-rotation-alignment", value);
- iconSize.parse("icon-size", value);
- iconTextFit.parse("icon-text-fit", value);
- iconTextFitPadding.parse("icon-text-fit-padding", value);
- iconImage.parse("icon-image", value);
- iconRotate.parse("icon-rotate", value);
- iconPadding.parse("icon-padding", value);
- iconKeepUpright.parse("icon-keep-upright", value);
- iconOffset.parse("icon-offset", value);
- textPitchAlignment.parse("text-pitch-alignment", value);
- textRotationAlignment.parse("text-rotation-alignment", value);
- textField.parse("text-field", value);
- textFont.parse("text-font", value);
- textSize.parse("text-size", value);
- textMaxWidth.parse("text-max-width", value);
- textLineHeight.parse("text-line-height", value);
- textLetterSpacing.parse("text-letter-spacing", value);
- textJustify.parse("text-justify", value);
- textAnchor.parse("text-anchor", value);
- textMaxAngle.parse("text-max-angle", value);
- textRotate.parse("text-rotate", value);
- textPadding.parse("text-padding", value);
- textKeepUpright.parse("text-keep-upright", value);
- textTransform.parse("text-transform", value);
- textOffset.parse("text-offset", value);
- textAllowOverlap.parse("text-allow-overlap", value);
- textIgnorePlacement.parse("text-ignore-placement", value);
- textOptional.parse("text-optional", value);
-}
-
void SymbolLayoutProperties::recalculate(const CalculationParameters& parameters) {
symbolPlacement.calculate(parameters);
symbolSpacing.calculate(parameters);
@@ -79,23 +42,6 @@ void SymbolLayoutProperties::recalculate(const CalculationParameters& parameters
textOptional.calculate(parameters);
}
-void SymbolPaintProperties::parse(const JSValue& value) {
- iconOpacity.parse("icon-opacity", value);
- iconColor.parse("icon-color", value);
- iconHaloColor.parse("icon-halo-color", value);
- iconHaloWidth.parse("icon-halo-width", value);
- iconHaloBlur.parse("icon-halo-blur", value);
- iconTranslate.parse("icon-translate", value);
- iconTranslateAnchor.parse("icon-translate-anchor", value);
- textOpacity.parse("text-opacity", value);
- textColor.parse("text-color", value);
- textHaloColor.parse("text-halo-color", value);
- textHaloWidth.parse("text-halo-width", value);
- textHaloBlur.parse("text-halo-blur", value);
- textTranslate.parse("text-translate", value);
- textTranslateAnchor.parse("text-translate-anchor", value);
-}
-
void SymbolPaintProperties::cascade(const CascadeParameters& parameters) {
iconOpacity.cascade(parameters);
iconColor.cascade(parameters);
diff --git a/src/mbgl/style/layers/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp
index 378562d605..a269969cb8 100644
--- a/src/mbgl/style/layers/symbol_layer_properties.hpp
+++ b/src/mbgl/style/layers/symbol_layer_properties.hpp
@@ -5,7 +5,6 @@
#include <mbgl/style/types.hpp>
#include <mbgl/style/layout_property.hpp>
#include <mbgl/style/paint_property.hpp>
-#include <mbgl/util/rapidjson.hpp>
namespace mbgl {
namespace style {
@@ -15,7 +14,6 @@ class CalculationParameters;
class SymbolLayoutProperties {
public:
- void parse(const JSValue&);
void recalculate(const CalculationParameters&);
LayoutProperty<SymbolPlacementType> symbolPlacement { SymbolPlacementType::Point };
@@ -56,7 +54,6 @@ public:
class SymbolPaintProperties {
public:
- void parse(const JSValue&);
void cascade(const CascadeParameters&);
bool recalculate(const CalculationParameters&);
diff --git a/src/mbgl/style/layout_property.hpp b/src/mbgl/style/layout_property.hpp
index f5045b47fc..db1a1ebf28 100644
--- a/src/mbgl/style/layout_property.hpp
+++ b/src/mbgl/style/layout_property.hpp
@@ -3,7 +3,6 @@
#include <mbgl/style/property_value.hpp>
#include <mbgl/style/property_parsing.hpp>
#include <mbgl/style/property_evaluator.hpp>
-#include <mbgl/util/rapidjson.hpp>
#include <utility>
@@ -25,12 +24,6 @@ public:
currentValue = value_;
}
- void parse(const char * name, const JSValue& layout) {
- if (layout.HasMember(name)) {
- currentValue = parseProperty<T>(name, layout[name]);
- }
- }
-
void calculate(const CalculationParameters& parameters) {
if (currentValue) {
PropertyEvaluator<T> evaluator(parameters, defaultValue);
diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp
index 7bb2e68b80..b982fe76e2 100644
--- a/src/mbgl/style/paint_property.hpp
+++ b/src/mbgl/style/paint_property.hpp
@@ -8,7 +8,6 @@
#include <mbgl/style/calculation_parameters.hpp>
#include <mbgl/util/constants.hpp>
#include <mbgl/util/interpolate.hpp>
-#include <mbgl/util/std.hpp>
#include <mbgl/util/rapidjson.hpp>
#include <map>
@@ -28,47 +27,28 @@ public:
}
PaintProperty(const PaintProperty& other)
- : values(other.values),
+ : defaultValue(other.defaultValue),
+ values(other.values),
transitions(other.transitions) {
}
+ PaintProperty& operator=(const PaintProperty& other) {
+ defaultValue = other.defaultValue;
+ values = other.values;
+ transitions = other.transitions;
+ return *this;
+ }
+
const PropertyValue<T>& get() const {
return values.at(ClassID::Default);
}
- void set(const PropertyValue<T>& value_) {
- values[ClassID::Default] = value_;
+ void set(const PropertyValue<T>& value_, const optional<std::string>& klass) {
+ values[klass ? ClassDictionary::Get().lookup(*klass) : ClassID::Default] = value_;
}
- void parse(const char* name, const JSValue& layer) {
- mbgl::util::erase_if(values, [] (const auto& p) { return p.first != ClassID::Fallback; });
-
- std::string transitionName = { name };
- transitionName += "-transition";
-
- for (auto it = layer.MemberBegin(); it != layer.MemberEnd(); ++it) {
- const std::string paintName { it->name.GetString(), it->name.GetStringLength() };
- if (paintName.compare(0, 5, "paint") != 0)
- continue;
-
- bool isClass = paintName.compare(0, 6, "paint.") == 0;
- if (isClass && paintName.length() <= 6)
- continue;
-
- ClassID classID = isClass ? ClassDictionary::Get().lookup(paintName.substr(6)) : ClassID::Default;
-
- if (it->value.HasMember(name)) {
- if (auto v = parseProperty<T>(name, it->value[name])) {
- values.emplace(classID, v);
- }
- }
-
- if (it->value.HasMember(transitionName.c_str())) {
- if (auto v = parseTransitionOptions(name, it->value[transitionName.c_str()])) {
- transitions.emplace(classID, *v);
- }
- }
- }
+ void setTransition(const TransitionOptions& transition, const optional<std::string>& klass) {
+ transitions[klass ? ClassDictionary::Get().lookup(*klass) : ClassID::Default] = transition;
}
void cascade(const CascadeParameters& params) {
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index a0f4dd24c9..ac263dbc57 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -11,7 +11,7 @@
#include <mbgl/style/layers/background_layer.hpp>
#include <mbgl/style/rapidjson_conversion.hpp>
#include <mbgl/style/conversion.hpp>
-#include <mbgl/style/conversion/filter.hpp>
+#include <mbgl/style/conversion/layer.hpp>
#include <mbgl/platform/log.hpp>
@@ -219,120 +219,16 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
return;
}
- layer = reference->baseImpl->copy(id, ref, reference->baseImpl->source);
- layer->baseImpl->parsePaints(value);
+ layer = reference->baseImpl->cloneRef(id);
+ conversion::setPaintProperties(*layer, value);
} else {
- // Otherwise, parse the source/source-layer/filter/render keys to form the bucket.
- if (!value.HasMember("type")) {
- Log::Warning(Event::ParseStyle, "layer '%s' is missing a type", id.c_str());
+ conversion::Result<std::unique_ptr<Layer>> converted = conversion::convert<std::unique_ptr<Layer>>(value);
+ if (!converted) {
+ Log::Warning(Event::ParseStyle, converted.error().message);
return;
}
-
- const JSValue& typeVal = value["type"];
- if (!typeVal.IsString()) {
- Log::Warning(Event::ParseStyle, "layer '%s' has an invalid type", id.c_str());
- return;
- }
-
- std::string type { typeVal.GetString(), typeVal.GetStringLength() };
- std::string source;
-
- if (value.HasMember("source")) {
- const JSValue& value_source = value["source"];
- if (value_source.IsString()) {
- source = { value_source.GetString(), value_source.GetStringLength() };
- auto source_it = sourcesMap.find(source);
- if (source_it == sourcesMap.end()) {
- Log::Warning(Event::ParseStyle, "can't find source '%s' required for layer '%s'", source.c_str(), id.c_str());
- }
- } else {
- Log::Warning(Event::ParseStyle, "source of layer '%s' must be a string", id.c_str());
- }
- }
-
- if (type == "fill") {
- layer = std::make_unique<FillLayer>(id, source);
- } else if (type == "line") {
- layer = std::make_unique<LineLayer>(id, source);
- } else if (type == "circle") {
- layer = std::make_unique<CircleLayer>(id, source);
- } else if (type == "symbol") {
- layer = std::make_unique<SymbolLayer>(id, source);
- } else if (type == "raster") {
- layer = std::make_unique<RasterLayer>(id, source);
- } else if (type == "background") {
- layer = std::make_unique<BackgroundLayer>(id);
- } else {
- Log::Warning(Event::ParseStyle, "unknown type '%s' for layer '%s'", type.c_str(), id.c_str());
- return;
- }
-
- Layer::Impl* impl = layer->baseImpl.get();
-
- if (value.HasMember("source-layer")) {
- const JSValue& value_source_layer = value["source-layer"];
- if (value_source_layer.IsString()) {
- impl->sourceLayer = { value_source_layer.GetString(), value_source_layer.GetStringLength() };
- } else {
- Log::Warning(Event::ParseStyle, "source-layer of layer '%s' must be a string", impl->id.c_str());
- }
- }
-
- if (value.HasMember("filter")) {
- conversion::Result<Filter> filter = conversion::convert<Filter>(value["filter"]);
- if (filter) {
- impl->filter = *filter;
- } else {
- Log::Warning(Event::ParseStyle, filter.error().message);
- }
- }
-
- if (value.HasMember("minzoom")) {
- const JSValue& min_zoom = value["minzoom"];
- if (min_zoom.IsNumber()) {
- impl->minZoom = min_zoom.GetDouble();
- } else {
- Log::Warning(Event::ParseStyle, "minzoom of layer %s must be numeric", impl->id.c_str());
- }
- }
-
- if (value.HasMember("maxzoom")) {
- const JSValue& max_zoom = value["maxzoom"];
- if (max_zoom.IsNumber()) {
- impl->maxZoom = max_zoom.GetDouble();
- } else {
- Log::Warning(Event::ParseStyle, "maxzoom of layer %s must be numeric", impl->id.c_str());
- }
- }
-
- if (value.HasMember("layout")) {
- parseVisibility(*layer, value["layout"]);
- impl->parseLayout(value["layout"]);
- }
-
- impl->parsePaints(value);
- }
-}
-
-void Parser::parseVisibility(Layer& layer, const JSValue& value) {
- Layer::Impl& impl = *layer.baseImpl;
-
- if (!value.HasMember("visibility")) {
- return;
- }
-
- if (!value["visibility"].IsString()) {
- Log::Warning(Event::ParseStyle, "value of 'visibility' must be a string");
- return;
+ layer = std::move(*converted);
}
-
- const auto enumValue = Enum<VisibilityType>::toEnum({ value["visibility"].GetString(), value["visibility"].GetStringLength() });
- if (!enumValue) {
- Log::Warning(Event::ParseStyle, "value of 'visibility' must be a valid enumeration value");
- return;
- }
-
- impl.visibility = *enumValue;
}
std::vector<FontStack> Parser::fontStacks() const {
diff --git a/src/mbgl/style/parser.hpp b/src/mbgl/style/parser.hpp
index 30da0dd2b0..faf80cee93 100644
--- a/src/mbgl/style/parser.hpp
+++ b/src/mbgl/style/parser.hpp
@@ -34,7 +34,6 @@ private:
void parseSources(const JSValue&);
void parseLayers(const JSValue&);
void parseLayer(const std::string& id, const JSValue&, std::unique_ptr<Layer>&);
- void parseVisibility(Layer&, const JSValue& value);
std::unordered_map<std::string, const Source*> sourcesMap;
std::unordered_map<std::string, std::pair<const JSValue&, std::unique_ptr<Layer>>> layersMap;
diff --git a/src/mbgl/style/rapidjson_conversion.hpp b/src/mbgl/style/rapidjson_conversion.hpp
index 1d9f88efa3..ecf044fb64 100644
--- a/src/mbgl/style/rapidjson_conversion.hpp
+++ b/src/mbgl/style/rapidjson_conversion.hpp
@@ -2,11 +2,16 @@
#include <mbgl/util/rapidjson.hpp>
#include <mbgl/util/feature.hpp>
+#include <mbgl/style/conversion.hpp>
namespace mbgl {
namespace style {
namespace conversion {
+inline bool isUndefined(const JSValue& value) {
+ return value.IsNull();
+}
+
inline bool isArray(const JSValue& value) {
return value.IsArray();
}
@@ -30,6 +35,17 @@ inline const JSValue* objectMember(const JSValue& value, const char * name) {
return &value[name];
}
+template <class Fn>
+optional<Error> eachMember(const JSValue& value, Fn&& fn) {
+ for (auto it = value.MemberBegin(); it != value.MemberEnd(); ++it) {
+ optional<Error> result = fn({it->name.GetString(), it->name.GetStringLength()}, it->value);
+ if (result) {
+ return result;
+ }
+ }
+ return {};
+}
+
inline optional<bool> toBool(const JSValue& value) {
if (!value.IsBool()) {
return {};
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index cb48790c9f..9073894cc2 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -141,6 +141,8 @@ Layer* Style::getLayer(const std::string& id) const {
}
void Style::addLayer(std::unique_ptr<Layer> layer, optional<std::string> before) {
+ // TODO: verify source
+
if (SymbolLayer* symbolLayer = layer->as<SymbolLayer>()) {
if (!symbolLayer->impl->spriteAtlas) {
symbolLayer->impl->spriteAtlas = spriteAtlas.get();
diff --git a/test/fixtures/style_parser/circle-blur.info.json b/test/fixtures/style_parser/circle-blur.info.json
index 60306e20c8..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-blur.info.json
+++ b/test/fixtures/style_parser/circle-blur.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "circle-blur: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/circle-blur.style.json b/test/fixtures/style_parser/circle-blur.style.json
index 8140ad5e47..9c82142c21 100644
--- a/test/fixtures/style_parser/circle-blur.style.json
+++ b/test/fixtures/style_parser/circle-blur.style.json
@@ -12,7 +12,7 @@
"type": "circle",
"source": "mapbox",
"paint": {
- "circle-blur": null
+ "circle-blur": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/circle-color.info.json b/test/fixtures/style_parser/circle-color.info.json
index 9d569ad53d..0dfa6371b7 100644
--- a/test/fixtures/style_parser/circle-color.info.json
+++ b/test/fixtures/style_parser/circle-color.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "circle-color: value must be a string"]
+ [1, "WARNING", "ParseStyle", "value must be a string"]
]
}
}
diff --git a/test/fixtures/style_parser/circle-color.style.json b/test/fixtures/style_parser/circle-color.style.json
index 44c32f99ce..e9c508304b 100644
--- a/test/fixtures/style_parser/circle-color.style.json
+++ b/test/fixtures/style_parser/circle-color.style.json
@@ -12,7 +12,7 @@
"type": "circle",
"source": "mapbox",
"paint": {
- "circle-color": null
+ "circle-color": 1
}
}]
}
diff --git a/test/fixtures/style_parser/circle-opacity.info.json b/test/fixtures/style_parser/circle-opacity.info.json
index bb77cebd1e..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-opacity.info.json
+++ b/test/fixtures/style_parser/circle-opacity.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "circle-opacity: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/circle-opacity.style.json b/test/fixtures/style_parser/circle-opacity.style.json
index 601e81a51b..a993182b1b 100644
--- a/test/fixtures/style_parser/circle-opacity.style.json
+++ b/test/fixtures/style_parser/circle-opacity.style.json
@@ -12,7 +12,7 @@
"type": "circle",
"source": "mapbox",
"paint": {
- "circle-opacity": null
+ "circle-opacity": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/circle-radius.info.json b/test/fixtures/style_parser/circle-radius.info.json
index 285e962d74..40c4632c0e 100644
--- a/test/fixtures/style_parser/circle-radius.info.json
+++ b/test/fixtures/style_parser/circle-radius.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "circle-radius: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/circle-radius.style.json b/test/fixtures/style_parser/circle-radius.style.json
index a7fb28b2d3..f12cebff97 100644
--- a/test/fixtures/style_parser/circle-radius.style.json
+++ b/test/fixtures/style_parser/circle-radius.style.json
@@ -12,7 +12,7 @@
"type": "circle",
"source": "mapbox",
"paint": {
- "circle-radius": null
+ "circle-radius": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/function-numeric.info.json b/test/fixtures/style_parser/function-numeric.info.json
index 906cccf106..7dd5a69561 100644
--- a/test/fixtures/style_parser/function-numeric.info.json
+++ b/test/fixtures/style_parser/function-numeric.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-width: function stop must be an array"]
+ [1, "WARNING", "ParseStyle", "function stop must be an array"]
]
}
}
diff --git a/test/fixtures/style_parser/function-type.info.json b/test/fixtures/style_parser/function-type.info.json
index 8a844bf7c1..c9e26537f7 100644
--- a/test/fixtures/style_parser/function-type.info.json
+++ b/test/fixtures/style_parser/function-type.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-width: function value must specify stops"]
+ [1, "WARNING", "ParseStyle", "function value must specify stops"]
]
}
}
diff --git a/test/fixtures/style_parser/line-opacity.info.json b/test/fixtures/style_parser/line-opacity.info.json
index 63af59e280..40c4632c0e 100644
--- a/test/fixtures/style_parser/line-opacity.info.json
+++ b/test/fixtures/style_parser/line-opacity.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-opacity: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/line-opacity.style.json b/test/fixtures/style_parser/line-opacity.style.json
index 712b2b6f50..7d29fb312a 100644
--- a/test/fixtures/style_parser/line-opacity.style.json
+++ b/test/fixtures/style_parser/line-opacity.style.json
@@ -16,7 +16,7 @@
"paint": {
"line-color": "#008",
"line-width": 0.9,
- "line-opacity": null
+ "line-opacity": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/line-translate.info.json b/test/fixtures/style_parser/line-translate.info.json
index a23e17012e..16df094290 100644
--- a/test/fixtures/style_parser/line-translate.info.json
+++ b/test/fixtures/style_parser/line-translate.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-translate: value must be an array of two numbers"]
+ [1, "WARNING", "ParseStyle", "value must be an array of two numbers"]
]
}
}
diff --git a/test/fixtures/style_parser/line-translate.style.json b/test/fixtures/style_parser/line-translate.style.json
index a32b2d8ee4..4890a8b6df 100644
--- a/test/fixtures/style_parser/line-translate.style.json
+++ b/test/fixtures/style_parser/line-translate.style.json
@@ -12,7 +12,7 @@
"type": "line",
"source": "mapbox",
"paint": {
- "line-translate": null
+ "line-translate": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/line-width.info.json b/test/fixtures/style_parser/line-width.info.json
index 9e549a0228..40c4632c0e 100644
--- a/test/fixtures/style_parser/line-width.info.json
+++ b/test/fixtures/style_parser/line-width.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-width: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/line-width.style.json b/test/fixtures/style_parser/line-width.style.json
index e5fe6fa8e1..1f677460c4 100644
--- a/test/fixtures/style_parser/line-width.style.json
+++ b/test/fixtures/style_parser/line-width.style.json
@@ -14,7 +14,7 @@
"source-layer": "waterway",
"filter": ["in", "type", "river", "canal"],
"paint": {
- "line-width": null
+ "line-width": "no"
}
}]
}
diff --git a/test/fixtures/style_parser/stop-zoom-value.info.json b/test/fixtures/style_parser/stop-zoom-value.info.json
index 3abf1867a4..386dce9d29 100644
--- a/test/fixtures/style_parser/stop-zoom-value.info.json
+++ b/test/fixtures/style_parser/stop-zoom-value.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "fill-opacity: function stop must have two elements"]
+ [1, "WARNING", "ParseStyle", "function stop must have two elements"]
]
}
}
diff --git a/test/fixtures/style_parser/stops-array.info.json b/test/fixtures/style_parser/stops-array.info.json
index b82f5a97d7..ed66513fee 100644
--- a/test/fixtures/style_parser/stops-array.info.json
+++ b/test/fixtures/style_parser/stops-array.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "line-width: function stops must be an array"]
+ [1, "WARNING", "ParseStyle", "function stops must be an array"]
]
}
}
diff --git a/test/fixtures/style_parser/text-size.info.json b/test/fixtures/style_parser/text-size.info.json
index b412c6beed..40c4632c0e 100644
--- a/test/fixtures/style_parser/text-size.info.json
+++ b/test/fixtures/style_parser/text-size.info.json
@@ -1,7 +1,7 @@
{
"default": {
"log": [
- [1, "WARNING", "ParseStyle", "text-size: value must be a number"]
+ [1, "WARNING", "ParseStyle", "value must be a number"]
]
}
}
diff --git a/test/fixtures/style_parser/text-size.style.json b/test/fixtures/style_parser/text-size.style.json
index ee6a6c39e4..dafa87d63b 100644
--- a/test/fixtures/style_parser/text-size.style.json
+++ b/test/fixtures/style_parser/text-size.style.json
@@ -14,7 +14,7 @@
"source-layer": "country_label",
"filter": ["==", "$type", "Point"],
"layout": {
- "text-size": null
+ "text-size": "no"
}
}]
}