diff options
96 files changed, 6841 insertions, 53 deletions
@@ -253,6 +253,8 @@ ifabric: $(IOS_PROJ_PATH) idocument: OUTPUT=$(OUTPUT) ./platform/ios/scripts/document.sh +style-code-darwin: + node platform/darwin/scripts/generate-style-code.js endif #### Linux targets ##################################################### diff --git a/platform/darwin/scripts/generate-style-code.js b/platform/darwin/scripts/generate-style-code.js new file mode 100644 index 0000000000..fd1cf2f66d --- /dev/null +++ b/platform/darwin/scripts/generate-style-code.js @@ -0,0 +1,211 @@ +'use strict'; + +const fs = require('fs'); +const ejs = require('ejs'); +const spec = require('mapbox-gl-style-spec').latest; + +var prefix = 'MGL'; +var suffix = 'StyleLayer'; + +global.camelize = function (str) { + return str.replace(/(?:^|-)(.)/g, function (_, x) { + return x.toUpperCase(); + }); +}; + +global.camelizeWithLeadingLowercase = function (str) { + return str.replace(/-(.)/g, function (_, x) { + return x.toUpperCase(); + }); +}; + +global.objCName = function (property) { return camelizeWithLeadingLowercase(property.name); } + +global.testImplementation = function (property, layerType) { + switch (property.type) { + case 'boolean': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testBool;`; + case 'number': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testNumber;`; + case 'string': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testString;`; + case 'enum': + var objCType = `${prefix}${camelize(layerType)}${suffix}${camelize(property.name)}`; + var objCEnum = `${objCType}${camelize(property.values[property.values.length-1])}`; + return `layer.${objCName(property)} = [MGLRuntimeStylingHelper testEnum:${objCEnum} type:@encode(${objCType})];`; + case 'color': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testColor;`; + case 'array': + return testArrayImplementation(property); + default: throw new Error(`unknown type for ${property.name}`) + } +} + +global.testGetterImplementation = function (property, layerType) { + switch (property.type) { + case 'boolean': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testBool);`; + case 'number': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testNumber);`; + case 'string': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testString);`; + case 'enum': + var objCType = `${prefix}${camelize(layerType)}${suffix}${camelize(property.name)}`; + var objCEnum = `${objCType}${camelize(property.values[property.values.length-1])}`; + return `XCTAssert([(NSValue *)gLayer.${objCName(property)} objCType] == [[MGLRuntimeStylingHelper testEnum:${objCEnum} type:@encode(${objCType})] objCType]);`; + case 'color': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testColor);`; + case 'array': + return testGetterArrayImplementation(property); + default: throw new Error(`unknown type for ${property.name}`) + } +} + +global.testGetterArrayImplementation = function (property) { + switch (property.name) { + case 'icon-text-fit-padding': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testPadding);`; + case 'line-dasharray': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testDashArray);`; + case 'text-font': + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testFont);`; + default: + return `XCTAssertEqualObjects(gLayer.${objCName(property)}, MGLRuntimeStylingHelper.testOffset);`; // Default offset (dx, dy) + } +}; + +global.testArrayImplementation = function (property) { + switch (property.name) { + case 'icon-text-fit-padding': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testPadding;`; + case 'line-dasharray': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testDashArray;`; + case 'text-font': + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testFont;`; + default: + return `layer.${objCName(property)} = MGLRuntimeStylingHelper.testOffset;`; // Default offset (dx, dy) + } +}; + +global.propertyType = function (property, _private) { + return _private ? `id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>` : `id <MGLStyleAttributeValue>`; +}; + +global.initLayer = function (layerType) { + if (layerType == "background") { + return `_layer = new mbgl::style::${camelize(layerType)}Layer(layerIdentifier.UTF8String);` + } else { + return `_layer = new mbgl::style::${camelize(layerType)}Layer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String);` + } +} + +global.setterImplementation = function(property, layerType) { + switch (property.type) { + case 'boolean': + return `self.layer->set${camelize(property.name)}(${objCName(property)}.mbgl_boolPropertyValue);`; + case 'number': + return `self.layer->set${camelize(property.name)}(${objCName(property)}.mbgl_floatPropertyValue);`; + case 'string': + return `self.layer->set${camelize(property.name)}(${objCName(property)}.mbgl_stringPropertyValue);`; + case 'enum': + var objCType = `${prefix}${camelize(layerType)}${suffix}${camelize(property.name)}`; + return `MGLSetEnumProperty(${objCName(property)}, ${camelize(property.name)}, ${mbglType(property)}, ${objCType});`; + case 'color': + return `self.layer->set${camelize(property.name)}(${objCName(property)}.mbgl_colorPropertyValue);`; + case 'array': + return arraySetterImplementation(property); + default: throw new Error(`unknown type for ${property.name}`) + } +} + +global.mbglType = function(property) { + var mbglType = camelize(property.name) + 'Type'; + if (/-translate-anchor$/.test(property.name)) { + mbglType = 'TranslateAnchorType'; + } + if (/-(rotation|pitch)-alignment$/.test(property.name)) { + mbglType = 'AlignmentType'; + } + return mbglType; +} + +global.arraySetterImplementation = function(property) { + return `self.layer->set${camelize(property.name)}(${objCName(property)}.mbgl_${convertedType(property)}PropertyValue);`; +} + +global.getterImplementation = function(property, layerType) { + switch (property.type) { + case 'boolean': + return `return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->get${camelize(property.name)}()];` + case 'number': + return `return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->get${camelize(property.name)}()];` + case 'string': + return `return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->get${camelize(property.name)}()];` + case 'enum': + var objCType = `${prefix}${camelize(layerType)}${suffix}${camelize(property.name)}`; + return `MGLGetEnumProperty(${camelize(property.name)}, ${mbglType(property)}, ${objCType});`; + case 'color': + return `return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->get${camelize(property.name)}()];` + case 'array': + return arrayGetterImplementation(property); + default: + throw new Error(`unknown type for ${property.name}`) + } +} + +global.arrayGetterImplementation = function(property) { + return `return [MGLStyleAttribute mbgl_${convertedType(property)}PropertyValueWith:self.layer->get${camelize(property.name)}()];` +} + +global.convertedType = function(property) { + switch (property.name) { + case 'boolean': + return 'bool'; + case 'number': + return 'number'; + case 'color': + return 'color'; + case 'string': + return 'string'; + case 'icon-text-fit-padding': + return "padding"; + case 'line-dasharray': + return "numberArray"; + case 'text-font': + return "stringArray"; + default: + return "offset"; + } +} + +const layerH = ejs.compile(fs.readFileSync('platform/darwin/src/MGLStyleLayer.h.ejs', 'utf8'), { strict: true }); +const layerM = ejs.compile(fs.readFileSync('platform/darwin/src/MGLStyleLayer.mm.ejs', 'utf8'), { strict: true}); +const testLayers = ejs.compile(fs.readFileSync('platform/darwin/src/MGLRuntimeStylingTests.m.ejs', 'utf8'), { strict: true}); + +const layers = spec.layer.type.values.map((type) => { + const layoutProperties = Object.keys(spec[`layout_${type}`]).reduce((memo, name) => { + if (name !== 'visibility') { + spec[`layout_${type}`][name].name = name; + memo.push(spec[`layout_${type}`][name]); + } + return memo; + }, []); + + const paintProperties = Object.keys(spec[`paint_${type}`]).reduce((memo, name) => { + spec[`paint_${type}`][name].name = name; + memo.push(spec[`paint_${type}`][name]); + return memo; + }, []); + + return { + type: type, + layoutProperties: layoutProperties, + paintProperties: paintProperties, + }; +}); + +for (const layer of layers) { + fs.writeFileSync(`platform/darwin/src/${prefix}${camelize(layer.type)}${suffix}.h`, layerH(layer)); + fs.writeFileSync(`platform/darwin/src/${prefix}${camelize(layer.type)}${suffix}.mm`, layerM(layer)); + fs.writeFileSync(`platform/darwin/test/${prefix}${camelize(layer.type)}${suffix}Tests.m`, testLayers(layer)); +} diff --git a/platform/darwin/src/MGLBackgroundStyleLayer.h b/platform/darwin/src/MGLBackgroundStyleLayer.h new file mode 100644 index 0000000000..4b0fddeceb --- /dev/null +++ b/platform/darwin/src/MGLBackgroundStyleLayer.h @@ -0,0 +1,27 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +@interface MGLBackgroundStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Paint Attributes + +/** + The color with which the background will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> backgroundColor; + +/** + Name of image in sprite to use for drawing an image background. For seamless patterns, image width and height must be a factor of two (2, 4, 8, ..., 512). + */ +@property (nonatomic) id <MGLStyleAttributeValue> backgroundPattern; + +/** + The opacity at which the background will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> backgroundOpacity; + +@end diff --git a/platform/darwin/src/MGLBackgroundStyleLayer.mm b/platform/darwin/src/MGLBackgroundStyleLayer.mm new file mode 100644 index 0000000000..66e308bb1f --- /dev/null +++ b/platform/darwin/src/MGLBackgroundStyleLayer.mm @@ -0,0 +1,57 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLBackgroundStyleLayer.h" + +#include <mbgl/style/layers/background_layer.hpp> + +@interface MGLBackgroundStyleLayer () + +@property (nonatomic) mbgl::style::BackgroundLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLBackgroundStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::BackgroundLayer(layerIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setBackgroundColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)backgroundColor { + self.layer->setBackgroundColor(backgroundColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)backgroundColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getBackgroundColor()]; +} + +- (void)setBackgroundPattern:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)backgroundPattern { + self.layer->setBackgroundPattern(backgroundPattern.mbgl_stringPropertyValue); +} + +- (id <MGLStyleAttributeValue>)backgroundPattern { + return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->getBackgroundPattern()]; +} + +- (void)setBackgroundOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)backgroundOpacity { + self.layer->setBackgroundOpacity(backgroundOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)backgroundOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getBackgroundOpacity()]; +} + +@end diff --git a/platform/darwin/src/MGLBaseStyleLayer.h b/platform/darwin/src/MGLBaseStyleLayer.h new file mode 100644 index 0000000000..597b67cdc2 --- /dev/null +++ b/platform/darwin/src/MGLBaseStyleLayer.h @@ -0,0 +1,22 @@ +#import <Foundation/Foundation.h> + +@interface MGLBaseStyleLayer : NSObject + +@property (nonatomic, assign, getter=isVisible) BOOL visible; + +/** + The maximum zoom level on which the layer gets parsed and appears on. + */ +@property (nonatomic, assign) float maximumZoomLevel; + +/** + The minimum zoom level on which the layer gets parsed and appears on. + */ +@property (nonatomic, assign) float minimumZoomLevel; + +/** + Updates the layer’s layout and paint properties. + */ +- (void)update; + +@end diff --git a/platform/darwin/src/MGLBaseStyleLayer.mm b/platform/darwin/src/MGLBaseStyleLayer.mm new file mode 100644 index 0000000000..c567ce33d8 --- /dev/null +++ b/platform/darwin/src/MGLBaseStyleLayer.mm @@ -0,0 +1,56 @@ +#import "MGLBaseStyleLayer.h" + +#import "MGLStyleLayer_Private.hpp" +#import "MGLMapView_Private.hpp" + +#include <mbgl/style/layer.hpp> + +@interface MGLBaseStyleLayer() <MGLStyleLayer_Private> +@end + +@implementation MGLBaseStyleLayer + +@synthesize layerIdentifier; +@synthesize mapView; +@synthesize layer; + +- (void)update +{ + self.mapView.mbglMap->update(mbgl::Update::RecalculateStyle | mbgl::Update::Classes); +} + +- (void)setVisible:(BOOL)visible +{ + mbgl::style::VisibilityType v = visible + ? mbgl::style::VisibilityType::Visible + : mbgl::style::VisibilityType::None; + self.layer->setVisibility(v); +} + +- (BOOL)isVisible +{ + mbgl::style::VisibilityType v = self.layer->getVisibility(); + return (v == mbgl::style::VisibilityType::Visible); +} + +- (void)setMaximumZoomLevel:(float)maximumZoomLevel +{ + self.layer->setMaxZoom(maximumZoomLevel); +} + +- (float)maximumZoomLevel +{ + return self.layer->getMaxZoom(); +} + +- (void)setMinimumZoomLevel:(float)minimumZoomLevel +{ + self.layer->setMinZoom(minimumZoomLevel); +} + +- (float)minimumZoomLevel +{ + return self.layer->getMinZoom(); +} + +@end diff --git a/platform/darwin/src/MGLCircleStyleLayer.h b/platform/darwin/src/MGLCircleStyleLayer.h new file mode 100644 index 0000000000..eaab3b843d --- /dev/null +++ b/platform/darwin/src/MGLCircleStyleLayer.h @@ -0,0 +1,57 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +typedef NS_ENUM(NSUInteger, MGLCircleStyleLayerCircleTranslateAnchor) { + MGLCircleStyleLayerCircleTranslateAnchorMap, + MGLCircleStyleLayerCircleTranslateAnchorViewport, +}; + +typedef NS_ENUM(NSUInteger, MGLCircleStyleLayerCirclePitchScale) { + MGLCircleStyleLayerCirclePitchScaleMap, + MGLCircleStyleLayerCirclePitchScaleViewport, +}; + +@interface MGLCircleStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Paint Attributes + +/** + Circle radius. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleRadius; + +/** + The color of the circle. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleColor; + +/** + Amount to blur the circle. 1 blurs the circle such that only the centerpoint is full opacity. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleBlur; + +/** + The opacity at which the circle will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleOpacity; + +/** + The geometry's offset. Values are [x, y] where negatives indicate left and up, respectively. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleTranslate; + +/** + Control whether the translation is relative to the map (north) or viewport (screen) + */ +@property (nonatomic) id <MGLStyleAttributeValue> circleTranslateAnchor; + +/** + Controls the scaling behavior of the circle when the map is pitched. The value `map` scales circles according to their apparent distance to the camera. The value `viewport` results in no pitch-related scaling. + */ +@property (nonatomic) id <MGLStyleAttributeValue> circlePitchScale; + +@end diff --git a/platform/darwin/src/MGLCircleStyleLayer.mm b/platform/darwin/src/MGLCircleStyleLayer.mm new file mode 100644 index 0000000000..44d6e39e79 --- /dev/null +++ b/platform/darwin/src/MGLCircleStyleLayer.mm @@ -0,0 +1,89 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLCircleStyleLayer.h" + +#include <mbgl/style/layers/circle_layer.hpp> + +@interface MGLCircleStyleLayer () + +@property (nonatomic) mbgl::style::CircleLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLCircleStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::CircleLayer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setCircleRadius:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleRadius { + self.layer->setCircleRadius(circleRadius.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)circleRadius { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getCircleRadius()]; +} + +- (void)setCircleColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleColor { + self.layer->setCircleColor(circleColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)circleColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getCircleColor()]; +} + +- (void)setCircleBlur:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleBlur { + self.layer->setCircleBlur(circleBlur.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)circleBlur { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getCircleBlur()]; +} + +- (void)setCircleOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleOpacity { + self.layer->setCircleOpacity(circleOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)circleOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getCircleOpacity()]; +} + +- (void)setCircleTranslate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleTranslate { + self.layer->setCircleTranslate(circleTranslate.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)circleTranslate { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getCircleTranslate()]; +} + +- (void)setCircleTranslateAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circleTranslateAnchor { + MGLSetEnumProperty(circleTranslateAnchor, CircleTranslateAnchor, TranslateAnchorType, MGLCircleStyleLayerCircleTranslateAnchor); +} + +- (id <MGLStyleAttributeValue>)circleTranslateAnchor { + MGLGetEnumProperty(CircleTranslateAnchor, TranslateAnchorType, MGLCircleStyleLayerCircleTranslateAnchor); +} + +- (void)setCirclePitchScale:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)circlePitchScale { + MGLSetEnumProperty(circlePitchScale, CirclePitchScale, CirclePitchScaleType, MGLCircleStyleLayerCirclePitchScale); +} + +- (id <MGLStyleAttributeValue>)circlePitchScale { + MGLGetEnumProperty(CirclePitchScale, CirclePitchScaleType, MGLCircleStyleLayerCirclePitchScale); +} + +@end diff --git a/platform/darwin/src/MGLFillStyleLayer.h b/platform/darwin/src/MGLFillStyleLayer.h new file mode 100644 index 0000000000..06a58b12bd --- /dev/null +++ b/platform/darwin/src/MGLFillStyleLayer.h @@ -0,0 +1,52 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +typedef NS_ENUM(NSUInteger, MGLFillStyleLayerFillTranslateAnchor) { + MGLFillStyleLayerFillTranslateAnchorMap, + MGLFillStyleLayerFillTranslateAnchorViewport, +}; + +@interface MGLFillStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Paint Attributes + +/** + Whether or not the fill should be antialiased. + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillAntialias; + +/** + The opacity of the entire fill layer. In contrast to the fill-color, this value will also affect the 1px stroke around the fill, if the stroke is used. + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillOpacity; + +/** + The color of the filled part of this layer. This color can be specified as rgba with an alpha component and the color's opacity will not affect the opacity of the 1px stroke, if it is used. + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillColor; + +/** + The outline color of the fill. Matches the value of `fill-color` if unspecified. + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillOutlineColor; + +/** + The geometry's offset. Values are [x, y] where negatives indicate left and up, respectively. + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillTranslate; + +/** + Control whether the translation is relative to the map (north) or viewport (screen) + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillTranslateAnchor; + +/** + Name of image in sprite to use for drawing image fills. For seamless patterns, image width and height must be a factor of two (2, 4, 8, ..., 512). + */ +@property (nonatomic) id <MGLStyleAttributeValue> fillPattern; + +@end diff --git a/platform/darwin/src/MGLFillStyleLayer.mm b/platform/darwin/src/MGLFillStyleLayer.mm new file mode 100644 index 0000000000..95e82a2e52 --- /dev/null +++ b/platform/darwin/src/MGLFillStyleLayer.mm @@ -0,0 +1,89 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLFillStyleLayer.h" + +#include <mbgl/style/layers/fill_layer.hpp> + +@interface MGLFillStyleLayer () + +@property (nonatomic) mbgl::style::FillLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLFillStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::FillLayer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setFillAntialias:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillAntialias { + self.layer->setFillAntialias(fillAntialias.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillAntialias { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getFillAntialias()]; +} + +- (void)setFillOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillOpacity { + self.layer->setFillOpacity(fillOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getFillOpacity()]; +} + +- (void)setFillColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillColor { + self.layer->setFillColor(fillColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getFillColor()]; +} + +- (void)setFillOutlineColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillOutlineColor { + self.layer->setFillOutlineColor(fillOutlineColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillOutlineColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getFillOutlineColor()]; +} + +- (void)setFillTranslate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillTranslate { + self.layer->setFillTranslate(fillTranslate.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillTranslate { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getFillTranslate()]; +} + +- (void)setFillTranslateAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillTranslateAnchor { + MGLSetEnumProperty(fillTranslateAnchor, FillTranslateAnchor, TranslateAnchorType, MGLFillStyleLayerFillTranslateAnchor); +} + +- (id <MGLStyleAttributeValue>)fillTranslateAnchor { + MGLGetEnumProperty(FillTranslateAnchor, TranslateAnchorType, MGLFillStyleLayerFillTranslateAnchor); +} + +- (void)setFillPattern:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)fillPattern { + self.layer->setFillPattern(fillPattern.mbgl_stringPropertyValue); +} + +- (id <MGLStyleAttributeValue>)fillPattern { + return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->getFillPattern()]; +} + +@end diff --git a/platform/darwin/src/MGLGeoJSONSource.h b/platform/darwin/src/MGLGeoJSONSource.h new file mode 100644 index 0000000000..58c0f6b794 --- /dev/null +++ b/platform/darwin/src/MGLGeoJSONSource.h @@ -0,0 +1,9 @@ +#import "MGLSource.h" + +@interface MGLGeoJSONSource : MGLSource + +@property (nonatomic, readonly, copy) NSString *data; + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier URL:(NSURL *)url NS_DESIGNATED_INITIALIZER; + +@end diff --git a/platform/darwin/src/MGLGeoJSONSource.mm b/platform/darwin/src/MGLGeoJSONSource.mm new file mode 100644 index 0000000000..92c5b87e89 --- /dev/null +++ b/platform/darwin/src/MGLGeoJSONSource.mm @@ -0,0 +1,43 @@ +#import "MGLGeoJSONSource.h" + +#import "MGLSource_Private.hpp" + +#include <mbgl/style/sources/geojson_source.hpp> + +@interface MGLGeoJSONSource () + +@property (nonatomic, copy) NSURL *URL; + +@end + +@implementation MGLGeoJSONSource + +static NSString *MGLGeoJSONSourceType = @"geojson"; +static NSString *MGLGeoJSONDataKey = @"data"; + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier URL:(NSURL *)url +{ + if (self = [super initWithSourceIdentifier:sourceIdentifier sourceType:MGLGeoJSONSourceType]) { + _URL = url; + if (url.isFileURL) { + _data = [[NSString alloc] initWithContentsOfURL:url encoding:NSUTF8StringEncoding error:NULL]; + } else { + _data = url.absoluteString; + } + } + return self; +} + +- (std::unique_ptr<mbgl::style::Source>)mbgl_source +{ + auto source = std::make_unique<mbgl::style::GeoJSONSource>(self.sourceIdentifier.UTF8String); + if (_URL.isFileURL) { + const auto geojson = mapbox::geojson::parse(self.data.UTF8String).get<mapbox::geojson::feature_collection>(); + source->setGeoJSON(geojson); + } else { + source->setURL(self.data.UTF8String); + } + return std::move(source); +} + +@end diff --git a/platform/darwin/src/MGLLineStyleLayer.h b/platform/darwin/src/MGLLineStyleLayer.h new file mode 100644 index 0000000000..6f3472b0b3 --- /dev/null +++ b/platform/darwin/src/MGLLineStyleLayer.h @@ -0,0 +1,101 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +typedef NS_ENUM(NSUInteger, MGLLineStyleLayerLineCap) { + MGLLineStyleLayerLineCapButt, + MGLLineStyleLayerLineCapRound, + MGLLineStyleLayerLineCapSquare, +}; + +typedef NS_ENUM(NSUInteger, MGLLineStyleLayerLineJoin) { + MGLLineStyleLayerLineJoinBevel, + MGLLineStyleLayerLineJoinRound, + MGLLineStyleLayerLineJoinMiter, +}; + +typedef NS_ENUM(NSUInteger, MGLLineStyleLayerLineTranslateAnchor) { + MGLLineStyleLayerLineTranslateAnchorMap, + MGLLineStyleLayerLineTranslateAnchorViewport, +}; + +@interface MGLLineStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Layout Attributes + +/** + The display of line endings. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineCap; + +/** + The display of lines when joining. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineJoin; + +/** + Used to automatically convert miter joins to bevel joins for sharp angles. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineMiterLimit; + +/** + Used to automatically convert round joins to miter joins for shallow angles. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineRoundLimit; + +#pragma mark - Accessing the Paint Attributes + +/** + The opacity at which the line will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineOpacity; + +/** + The color with which the line will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineColor; + +/** + The geometry's offset. Values are [x, y] where negatives indicate left and up, respectively. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineTranslate; + +/** + Control whether the translation is relative to the map (north) or viewport (screen) + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineTranslateAnchor; + +/** + Stroke thickness. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineWidth; + +/** + Draws a line casing outside of a line's actual path. Value indicates the width of the inner gap. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineGapWidth; + +/** + The line's offset perpendicular to its direction. Values may be positive or negative, where positive indicates "rightwards" (if you were moving in the direction of the line) and negative indicates "leftwards." + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineOffset; + +/** + Blur applied to the line, in pixels. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineBlur; + +/** + Specifies the lengths of the alternating dashes and gaps that form the dash pattern. The lengths are later scaled by the line width. To convert a dash length to pixels, multiply the length by the current line width. + */ +@property (nonatomic) id <MGLStyleAttributeValue> lineDasharray; + +/** + Name of image in sprite to use for drawing image lines. For seamless patterns, image width must be a factor of two (2, 4, 8, ..., 512). + */ +@property (nonatomic) id <MGLStyleAttributeValue> linePattern; + +@end diff --git a/platform/darwin/src/MGLLineStyleLayer.mm b/platform/darwin/src/MGLLineStyleLayer.mm new file mode 100644 index 0000000000..8c6ee1e6d2 --- /dev/null +++ b/platform/darwin/src/MGLLineStyleLayer.mm @@ -0,0 +1,147 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLLineStyleLayer.h" + +#include <mbgl/style/layers/line_layer.hpp> + +@interface MGLLineStyleLayer () + +@property (nonatomic) mbgl::style::LineLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLLineStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::LineLayer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Layout Attributes + +- (void)setLineCap:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineCap { + MGLSetEnumProperty(lineCap, LineCap, LineCapType, MGLLineStyleLayerLineCap); +} + +- (id <MGLStyleAttributeValue>)lineCap { + MGLGetEnumProperty(LineCap, LineCapType, MGLLineStyleLayerLineCap); +} + +- (void)setLineJoin:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineJoin { + MGLSetEnumProperty(lineJoin, LineJoin, LineJoinType, MGLLineStyleLayerLineJoin); +} + +- (id <MGLStyleAttributeValue>)lineJoin { + MGLGetEnumProperty(LineJoin, LineJoinType, MGLLineStyleLayerLineJoin); +} + +- (void)setLineMiterLimit:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineMiterLimit { + self.layer->setLineMiterLimit(lineMiterLimit.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineMiterLimit { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineMiterLimit()]; +} + +- (void)setLineRoundLimit:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineRoundLimit { + self.layer->setLineRoundLimit(lineRoundLimit.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineRoundLimit { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineRoundLimit()]; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setLineOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineOpacity { + self.layer->setLineOpacity(lineOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineOpacity()]; +} + +- (void)setLineColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineColor { + self.layer->setLineColor(lineColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getLineColor()]; +} + +- (void)setLineTranslate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineTranslate { + self.layer->setLineTranslate(lineTranslate.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineTranslate { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getLineTranslate()]; +} + +- (void)setLineTranslateAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineTranslateAnchor { + MGLSetEnumProperty(lineTranslateAnchor, LineTranslateAnchor, TranslateAnchorType, MGLLineStyleLayerLineTranslateAnchor); +} + +- (id <MGLStyleAttributeValue>)lineTranslateAnchor { + MGLGetEnumProperty(LineTranslateAnchor, TranslateAnchorType, MGLLineStyleLayerLineTranslateAnchor); +} + +- (void)setLineWidth:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineWidth { + self.layer->setLineWidth(lineWidth.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineWidth { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineWidth()]; +} + +- (void)setLineGapWidth:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineGapWidth { + self.layer->setLineGapWidth(lineGapWidth.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineGapWidth { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineGapWidth()]; +} + +- (void)setLineOffset:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineOffset { + self.layer->setLineOffset(lineOffset.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineOffset { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineOffset()]; +} + +- (void)setLineBlur:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineBlur { + self.layer->setLineBlur(lineBlur.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineBlur { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getLineBlur()]; +} + +- (void)setLineDasharray:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)lineDasharray { + self.layer->setLineDasharray(lineDasharray.mbgl_numberArrayPropertyValue); +} + +- (id <MGLStyleAttributeValue>)lineDasharray { + return [MGLStyleAttribute mbgl_numberArrayPropertyValueWith:self.layer->getLineDasharray()]; +} + +- (void)setLinePattern:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)linePattern { + self.layer->setLinePattern(linePattern.mbgl_stringPropertyValue); +} + +- (id <MGLStyleAttributeValue>)linePattern { + return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->getLinePattern()]; +} + +@end diff --git a/platform/darwin/src/MGLRasterSource.h b/platform/darwin/src/MGLRasterSource.h new file mode 100644 index 0000000000..e563244bce --- /dev/null +++ b/platform/darwin/src/MGLRasterSource.h @@ -0,0 +1,10 @@ +#import "MGLSource.h" + +@interface MGLRasterSource : MGLSource + +@property (nonatomic, readonly, copy) NSURL *URL; +@property (nonatomic, readonly, assign) CGFloat tileSize; + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier URL:(NSURL *)url tileSize:(CGFloat)tileSize; + +@end diff --git a/platform/darwin/src/MGLRasterSource.mm b/platform/darwin/src/MGLRasterSource.mm new file mode 100644 index 0000000000..5f3881b285 --- /dev/null +++ b/platform/darwin/src/MGLRasterSource.mm @@ -0,0 +1,26 @@ +#import "MGLRasterSource.h" + +#import "MGLSource_Private.hpp" + +#include <mbgl/style/sources/raster_source.hpp> + +@implementation MGLRasterSource + +static NSString *MGLRasterSourceType = @"raster"; + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier URL:(NSURL *)url tileSize:(CGFloat)tileSize { + if (self = [super initWithSourceIdentifier:sourceIdentifier sourceType:MGLRasterSourceType]) { + _URL = url; + _tileSize = tileSize; + } + return self; +} + +- (std::unique_ptr<mbgl::style::Source>)mbgl_source { + auto source = std::make_unique<mbgl::style::RasterSource>(self.sourceIdentifier.UTF8String, + self.URL.absoluteString.UTF8String, + uint16_t(self.tileSize)); + return std::move(source); +} + +@end diff --git a/platform/darwin/src/MGLRasterStyleLayer.h b/platform/darwin/src/MGLRasterStyleLayer.h new file mode 100644 index 0000000000..e666862339 --- /dev/null +++ b/platform/darwin/src/MGLRasterStyleLayer.h @@ -0,0 +1,47 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +@interface MGLRasterStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Paint Attributes + +/** + The opacity at which the image will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterOpacity; + +/** + Rotates hues around the color wheel. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterHueRotate; + +/** + Increase or reduce the brightness of the image. The value is the minimum brightness. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterBrightnessMin; + +/** + Increase or reduce the brightness of the image. The value is the maximum brightness. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterBrightnessMax; + +/** + Increase or reduce the saturation of the image. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterSaturation; + +/** + Increase or reduce the contrast of the image. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterContrast; + +/** + Fade duration when a new tile is added. + */ +@property (nonatomic) id <MGLStyleAttributeValue> rasterFadeDuration; + +@end diff --git a/platform/darwin/src/MGLRasterStyleLayer.mm b/platform/darwin/src/MGLRasterStyleLayer.mm new file mode 100644 index 0000000000..f976f3ddaf --- /dev/null +++ b/platform/darwin/src/MGLRasterStyleLayer.mm @@ -0,0 +1,89 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLRasterStyleLayer.h" + +#include <mbgl/style/layers/raster_layer.hpp> + +@interface MGLRasterStyleLayer () + +@property (nonatomic) mbgl::style::RasterLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLRasterStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::RasterLayer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setRasterOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterOpacity { + self.layer->setRasterOpacity(rasterOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterOpacity()]; +} + +- (void)setRasterHueRotate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterHueRotate { + self.layer->setRasterHueRotate(rasterHueRotate.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterHueRotate { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterHueRotate()]; +} + +- (void)setRasterBrightnessMin:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterBrightnessMin { + self.layer->setRasterBrightnessMin(rasterBrightnessMin.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterBrightnessMin { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterBrightnessMin()]; +} + +- (void)setRasterBrightnessMax:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterBrightnessMax { + self.layer->setRasterBrightnessMax(rasterBrightnessMax.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterBrightnessMax { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterBrightnessMax()]; +} + +- (void)setRasterSaturation:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterSaturation { + self.layer->setRasterSaturation(rasterSaturation.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterSaturation { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterSaturation()]; +} + +- (void)setRasterContrast:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterContrast { + self.layer->setRasterContrast(rasterContrast.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterContrast { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterContrast()]; +} + +- (void)setRasterFadeDuration:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)rasterFadeDuration { + self.layer->setRasterFadeDuration(rasterFadeDuration.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)rasterFadeDuration { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getRasterFadeDuration()]; +} + +@end diff --git a/platform/darwin/src/MGLRuntimeStylingTests.m.ejs b/platform/darwin/src/MGLRuntimeStylingTests.m.ejs new file mode 100644 index 0000000000..fff6aaf697 --- /dev/null +++ b/platform/darwin/src/MGLRuntimeStylingTests.m.ejs @@ -0,0 +1,40 @@ +<% + const type = locals.type; + const layoutProperties = locals.layoutProperties; + const paintProperties = locals.paintProperties; +-%> +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGL<%- camelize(type) %>LayerTests : MGLStyleLayerTests +@end + +@implementation MGL<%- camelize(type) %>LayerTests + +- (void)test<%- camelize(type) %>Layer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGL<%- camelize(type) %>StyleLayer *layer = [[MGL<%- camelize(type) %>StyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + +<% for (const property of layoutProperties) { -%> + <%- testImplementation(property, type) %> +<% } -%> +<% for (const property of paintProperties) { -%> + <%- testImplementation(property, type) %> +<% } -%> + + MGL<%- camelize(type) %>StyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; +<% for (const property of layoutProperties) { -%> + <%- testGetterImplementation(property, type) %> +<% } -%> +<% for (const property of paintProperties) { -%> + <%- testGetterImplementation(property, type) %> +<% } -%> +} + +@end diff --git a/platform/darwin/src/MGLSource.h b/platform/darwin/src/MGLSource.h new file mode 100644 index 0000000000..b08a09ec4d --- /dev/null +++ b/platform/darwin/src/MGLSource.h @@ -0,0 +1,11 @@ +#import <Foundation/Foundation.h> +#import <CoreGraphics/CoreGraphics.h> + +@interface MGLSource : NSObject + +@property (nonatomic, copy) NSString *sourceIdentifier; +@property (nonatomic, copy) NSString *sourceType; + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier sourceType:(NSString *)sourceType; + +@end diff --git a/platform/darwin/src/MGLSource.mm b/platform/darwin/src/MGLSource.mm new file mode 100644 index 0000000000..c80fbe914c --- /dev/null +++ b/platform/darwin/src/MGLSource.mm @@ -0,0 +1,20 @@ +#import "MGLSource.h" + +#include <mbgl/style/source.hpp> + +@implementation MGLSource + +- (instancetype)initWithSourceIdentifier:(NSString *)sourceIdentifier sourceType:(NSString *)sourceType { + if (self = [super init]) { + _sourceIdentifier = sourceIdentifier; + _sourceType = sourceType; + } + return self; +} + +- (std::unique_ptr<mbgl::style::Source>)mbgl_source { + [NSException raise:@"Subclasses must override this method" format:@""]; + return nil; +} + +@end diff --git a/platform/darwin/src/MGLSource_Private.hpp b/platform/darwin/src/MGLSource_Private.hpp new file mode 100644 index 0000000000..bbbd556635 --- /dev/null +++ b/platform/darwin/src/MGLSource_Private.hpp @@ -0,0 +1,10 @@ +#import "MGLSource.h" + +#include <mbgl/mbgl.hpp> +#include <mbgl/style/source.hpp> + +@interface MGLSource (Private) + +- (std::unique_ptr<mbgl::style::Source>)mbgl_source; + +@end diff --git a/platform/darwin/src/MGLStyle.h b/platform/darwin/src/MGLStyle.h index 8577522b96..368557fc81 100644 --- a/platform/darwin/src/MGLStyle.h +++ b/platform/darwin/src/MGLStyle.h @@ -2,6 +2,10 @@ #import "MGLTypes.h" +#import "MGLStyleLayer.h" + +@class MGLSource; + NS_ASSUME_NONNULL_BEGIN /** @@ -32,6 +36,8 @@ static const NSInteger MGLStyleDefaultVersion = 9; */ @interface MGLStyle : NSObject +#pragma mark Default Style URLs + /** Returns the URL to version 8 of the <a href="https://www.mapbox.com/maps/streets/">Mapbox Streets</a> style. @@ -158,7 +164,54 @@ static const NSInteger MGLStyleDefaultVersion = 9; */ + (NSURL *)satelliteStreetsStyleURLWithVersion:(NSInteger)version; -- (instancetype)init NS_UNAVAILABLE; +#pragma mark Runtime Styling + +/** + Returns a layer that conforms to `MGLStyleLayer` if any layer with the given + identifier was found. + + @return layer A layer instance of the corresponding type. + */ +- (nullable id <MGLStyleLayer>)layerWithIdentifier:(NSString *)identifier; + +/** + Adds a new layer at the top of the hierarchy. + + @param styleLayer The layer object to add to the map view. This object + must conform to the `MGLStyleLayer` protocol. + */ +- (void)addLayer:(id <MGLStyleLayer>)styleLayer; + +/** + Inserts a new layer below another layer. + + @param styleLayer Layer to be inserted. + @param belowLayer A layer that's already on the map view. + */ +- (void)insertLayer:(id <MGLStyleLayer>)styleLayer + belowLayer:(id <MGLStyleLayer>)belowLayer; + +/** + Removes a layer from the map view. + + @param styleLayer The layer object to remove from the map view. This object + must conform to the `MGLStyleLayer` protocol. + */ +- (void)removeLayer:(id <MGLStyleLayer>)styleLayer; + +/** + Adds a new source to the map view. + + @param source The source to add to the map view. + */ +- (void)addSource:(MGLSource *)source; + +/** + Removes a source from the map view. + + @param source The source to remove. + */ +- (void)removeSource:(MGLSource *)source; @end diff --git a/platform/darwin/src/MGLStyle.mm b/platform/darwin/src/MGLStyle.mm index 347fc2be24..c75572052b 100644 --- a/platform/darwin/src/MGLStyle.mm +++ b/platform/darwin/src/MGLStyle.mm @@ -1,6 +1,32 @@ #import "MGLStyle.h" +#import "MGLMapView_Private.hpp" +#import "MGLStyleLayer.h" +#import "MGLFillStyleLayer.h" +#import "MGLLineStyleLayer.h" +#import "MGLCircleStyleLayer.h" +#import "MGLSymbolStyleLayer.h" +#import "MGLRasterStyleLayer.h" +#import "MGLBackgroundStyleLayer.h" + +#import "MGLStyle_Private.hpp" +#import "MGLStyleLayer_Private.hpp" +#import "MGLSource_Private.hpp" +#import "MGLSource.h" + #import <mbgl/util/default_styles.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/raster_layer.hpp> +#include <mbgl/style/layers/circle_layer.hpp> +#include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/style/sources/geojson_source.hpp> +#include <mbgl/mbgl.hpp> + +@interface MGLStyle() +@property (nonatomic, weak) MGLMapView *mapView; +@end @implementation MGLStyle @@ -54,4 +80,74 @@ static NSURL *MGLStyleURL_emerald; return MGLStyleURL_emerald; } +- (mbgl::style::Layer *)mbglLayerWithIdentifier:(NSString *)identifier +{ + return self.mapView.mbglMap->getLayer(identifier.UTF8String); +} + +- (mbgl::style::Source *)mbglSourceWithIdentifier:(NSString *)identifier +{ + return self.mapView.mbglMap->getSource(identifier.UTF8String); +} + +- (id <MGLStyleLayer>)layerWithIdentifier:(NSString *)identifier +{ + auto layer = self.mapView.mbglMap->getLayer(identifier.UTF8String); + + Class clazz = [self classFromLayer:layer]; + + id <MGLStyleLayer, MGLStyleLayer_Private> styleLayer = [[clazz alloc] init]; + styleLayer.layerIdentifier = identifier; + styleLayer.layer = layer; + styleLayer.mapView = self.mapView; + + return styleLayer; +} + +- (Class)classFromLayer:(mbgl::style::Layer *)layer +{ + if (layer->is<mbgl::style::FillLayer>()) { + return MGLFillStyleLayer.class; + } else if (layer->is<mbgl::style::LineLayer>()) { + return MGLLineStyleLayer.class; + } else if (layer->is<mbgl::style::SymbolLayer>()) { + return MGLSymbolStyleLayer.class; + } else if (layer->is<mbgl::style::RasterLayer>()) { + return MGLRasterStyleLayer.class; + } else if (layer->is<mbgl::style::CircleLayer>()) { + return MGLCircleStyleLayer.class; + } else if (layer->is<mbgl::style::BackgroundLayer>()) { + return MGLBackgroundStyleLayer.class; + } + [NSException raise:@"Layer type not handled" format:@""]; + return Nil; +} + +- (void)removeLayer:(id <MGLStyleLayer_Private>)styleLayer +{ + self.mapView.mbglMap->removeLayer(styleLayer.layer->getID()); +} + +- (void)addLayer:(id <MGLStyleLayer, MGLStyleLayer_Private>)styleLayer +{ + self.mapView.mbglMap->addLayer(std::unique_ptr<mbgl::style::Layer>(styleLayer.layer)); +} + +- (void)insertLayer:(id <MGLStyleLayer, MGLStyleLayer_Private>)styleLayer + belowLayer:(id <MGLStyleLayer, MGLStyleLayer_Private>)belowLayer +{ + const mbgl::optional<std::string> belowLayerId{[belowLayer layerIdentifier].UTF8String}; + self.mapView.mbglMap->addLayer(std::unique_ptr<mbgl::style::Layer>(styleLayer.layer), belowLayerId); +} + +- (void)addSource:(MGLSource *)source +{ + self.mapView.mbglMap->addSource(std::move([source mbgl_source])); +} + +- (void)removeSource:(MGLSource *)source +{ + self.mapView.mbglMap->removeSource(source.sourceIdentifier.UTF8String); +} + @end diff --git a/platform/darwin/src/MGLStyleAttribute.hpp b/platform/darwin/src/MGLStyleAttribute.hpp new file mode 100644 index 0000000000..1f9207f05a --- /dev/null +++ b/platform/darwin/src/MGLStyleAttribute.hpp @@ -0,0 +1,25 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue_Private.hpp" + +@interface MGLStyleAttribute : NSObject <MGLStyleAttributeValue> + ++ (id <MGLStyleAttributeValue>)mbgl_colorPropertyValueWith:(mbgl::style::PropertyValue<mbgl::Color>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_numberPropertyValueWith:(mbgl::style::PropertyValue<float>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_boolPropertyValueWith:(mbgl::style::PropertyValue<bool>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_stringPropertyValueWith:(mbgl::style::PropertyValue<std::string>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_offsetPropertyValueWith:(mbgl::style::PropertyValue<std::array<float, 2>>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_paddingPropertyValueWith:(mbgl::style::PropertyValue<std::array<float, 4>>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_stringArrayPropertyValueWith:(mbgl::style::PropertyValue<std::vector<std::string>>)property; + ++ (id <MGLStyleAttributeValue>)mbgl_numberArrayPropertyValueWith:(mbgl::style::PropertyValue<std::vector<float>>)property; + +@end diff --git a/platform/darwin/src/MGLStyleAttribute.mm b/platform/darwin/src/MGLStyleAttribute.mm new file mode 100644 index 0000000000..32c0f4e71e --- /dev/null +++ b/platform/darwin/src/MGLStyleAttribute.mm @@ -0,0 +1,111 @@ +#import "MGLStyleAttribute.hpp" + +#import "MGLStyleAttributeValue_Private.hpp" +#import "MGLStyleAttributeFunction_Private.hpp" + +@interface MGLStyleAttribute() +@end + +@implementation MGLStyleAttribute + ++ (id <MGLStyleAttributeValue>)mbgl_colorPropertyValueWith:(mbgl::style::PropertyValue<mbgl::Color>)property +{ + if (property.isConstant()) { + return [MGLColor mbgl_colorWithColor:property.asConstant()]; + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithColorPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id <MGLStyleAttributeValue>)mbgl_numberPropertyValueWith:(mbgl::style::PropertyValue<float>)property +{ + if (property.isConstant()) { + return @(property.asConstant()); + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithNumberPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_boolPropertyValueWith:(mbgl::style::PropertyValue<bool>)property +{ + if (property.isConstant()) { + return @(property.asConstant()); + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithBoolPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_stringPropertyValueWith:(mbgl::style::PropertyValue<std::string>)property +{ + if (property.isConstant()) { + return @(property.asConstant().c_str()); + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithStringPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_offsetPropertyValueWith:(mbgl::style::PropertyValue<std::array<float, 2> >)property +{ + if (property.isConstant()) { + auto offset = property.asConstant(); + return @[@(offset[0]), @(offset[1])]; + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithOffsetPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_paddingPropertyValueWith:(mbgl::style::PropertyValue<std::array<float, 4> >)property +{ + if (property.isConstant()) { + auto padding = property.asConstant(); + return @[@(padding[0]), @(padding[1]), @(padding[2]), @(padding[3])]; + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithPaddingPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_stringArrayPropertyValueWith:(mbgl::style::PropertyValue<std::vector<std::string> >)property +{ + if (property.isConstant()) { + auto strings = property.asConstant(); + NSMutableArray *convertedStrings = [[NSMutableArray alloc] initWithCapacity:strings.size()]; + for (auto string : strings) { + [convertedStrings addObject:@(string.c_str())]; + } + return convertedStrings; + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithStringArrayPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + ++ (id<MGLStyleAttributeValue>)mbgl_numberArrayPropertyValueWith:(mbgl::style::PropertyValue<std::vector<float> >)property +{ + if (property.isConstant()) { + auto numbers = property.asConstant(); + NSMutableArray *convertedNumbers = [NSMutableArray arrayWithCapacity:numbers.size()]; + for (auto number : numbers) { + [convertedNumbers addObject:@(number)]; + } + return convertedNumbers; + } else if (property.isFunction()) { + return [MGLStyleAttributeFunction functionWithNumberArrayPropertyValue:property.asFunction()]; + } else { + return nil; + } +} + +@end diff --git a/platform/darwin/src/MGLStyleAttributeFunction.h b/platform/darwin/src/MGLStyleAttributeFunction.h new file mode 100644 index 0000000000..dbef311548 --- /dev/null +++ b/platform/darwin/src/MGLStyleAttributeFunction.h @@ -0,0 +1,26 @@ +#import <Foundation/Foundation.h> + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" + +typedef NS_ENUM(NSUInteger, MGLStyleAttributeFunctionType) { + MGLStyleAttributeFunctionTypeExponential, + MGLStyleAttributeFunctionTypeInterval, + MGLStyleAttributeFunctionTypeCategorical +}; + +NS_ASSUME_NONNULL_BEGIN + +@interface MGLStyleAttributeFunction : NSObject <MGLStyleAttributeValue> + +@property (nonatomic, copy) NSDictionary<NSNumber *, id> *stops; + +@property (nonatomic, copy, nullable) NSString *property; + +@property (nonatomic, copy, nullable) NSNumber *base; + +@property (nonatomic, copy, nullable) NSNumber *functionType; + +@end + +NS_ASSUME_NONNULL_END diff --git a/platform/darwin/src/MGLStyleAttributeFunction.mm b/platform/darwin/src/MGLStyleAttributeFunction.mm new file mode 100644 index 0000000000..d97f8b720f --- /dev/null +++ b/platform/darwin/src/MGLStyleAttributeFunction.mm @@ -0,0 +1,243 @@ +#import "MGLStyleAttributeFunction.h" + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue_Private.hpp" +#import "MGLStyleAttributeFunction_Private.hpp" + +@interface MGLStyleAttributeFunction() <MGLStyleAttributeValue_Private> +@end + +@implementation MGLStyleAttributeFunction + +- (instancetype)init +{ + if (self = [super init]) { + _base = @1; + } + return self; +} + +- (BOOL)isFunction +{ + return YES; +} + +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue +{ + __block std::vector<std::pair<float, mbgl::Color>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, MGLColor * _Nonnull color, BOOL * _Nonnull stop) { + NSAssert([color isKindOfClass:[MGLColor class]], @"Stops should be colors"); + stops.emplace_back(zoomKey.floatValue, color.mbgl_color); + }]; + return mbgl::style::Function<mbgl::Color>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<float>)mbgl_floatPropertyValue +{ + __block std::vector<std::pair<float, float>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSNumber * _Nonnull number, BOOL * _Nonnull stop) { + NSAssert([number isKindOfClass:[NSNumber class]], @"Stops should be NSNumbers"); + stops.emplace_back(zoomKey.floatValue, number.floatValue); + }]; + return mbgl::style::Function<float>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<bool>)mbgl_boolPropertyValue +{ + __block std::vector<std::pair<float, bool>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSNumber * _Nonnull number, BOOL * _Nonnull stop) { + NSAssert([number isKindOfClass:[NSNumber class]], @"Stops should be NSNumbers"); + stops.emplace_back(zoomKey.floatValue, number.boolValue); + }]; + return mbgl::style::Function<bool>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<std::string>)mbgl_stringPropertyValue +{ + __block std::vector<std::pair<float, std::string>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSString * _Nonnull string, BOOL * _Nonnull stop) { + NSAssert([string isKindOfClass:[NSString class]], @"Stops should be strings"); + stops.emplace_back(zoomKey.floatValue, string.UTF8String); + }]; + return mbgl::style::Function<std::string>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<std::vector<std::string> >)mbgl_stringArrayPropertyValue +{ + __block std::vector<std::pair<float, std::vector<std::string>>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSArray * _Nonnull strings, BOOL * _Nonnull stop) { + NSAssert([strings isKindOfClass:[NSArray class]], @"Stops should be NSArray"); + std::vector<std::string>convertedStrings; + for (NSString *string in strings) { + convertedStrings.emplace_back(string.UTF8String); + } + stops.emplace_back(zoomKey.floatValue, convertedStrings); + }]; + return mbgl::style::Function<std::vector<std::string>>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<std::vector<float> >)mbgl_numberArrayPropertyValue +{ + __block std::vector<std::pair<float, std::vector<float>>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSArray * _Nonnull numbers, BOOL * _Nonnull stop) { + NSAssert([numbers isKindOfClass:[NSArray class]], @"Stops should be NSArray"); + std::vector<float>convertedNumbers; + for (NSNumber *number in numbers) { + convertedNumbers.emplace_back(number.floatValue); + } + stops.emplace_back(zoomKey.floatValue, convertedNumbers); + }]; + return mbgl::style::Function<std::vector<float>>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<std::array<float, 4> >)mbgl_paddingPropertyValue +{ + __block std::vector<std::pair<float, std::array<float, 4>>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSArray * _Nonnull padding, BOOL * _Nonnull stop) { + NSAssert([padding isKindOfClass:[NSArray class]], @"Stops should be NSArray"); + NSNumber *top = padding[0]; + NSNumber *left = padding[1]; + NSNumber *bottom = padding[2]; + NSNumber *right = padding[2]; + auto pad = std::array<float, 4>({{top.floatValue, left.floatValue, bottom.floatValue, right.floatValue}}); + stops.emplace_back(zoomKey.floatValue, pad); + }]; + return mbgl::style::Function<std::array<float, 4>>({{stops}}, _base.floatValue); +} + +- (mbgl::style::PropertyValue<std::array<float, 2> >)mbgl_offsetPropertyValue +{ + __block std::vector<std::pair<float, std::array<float, 2>>> stops; + [self.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSArray * _Nonnull offset, BOOL * _Nonnull stop) { + NSAssert([offset isKindOfClass:[NSArray class]], @"Stops should be NSArray"); + NSNumber *dx = offset[0]; + NSNumber *dy = offset[1]; + auto off = std::array<float, 2>({{dx.floatValue, dy.floatValue}}); + stops.emplace_back(zoomKey.floatValue, off); + }]; + return mbgl::style::Function<std::array<float, 2>>({{stops}}, _base.floatValue); +} + ++ (instancetype)functionWithColorPropertyValue:(mbgl::style::Function<mbgl::Color>)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = [MGLColor mbgl_colorWithColor:stop.second]; + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithNumberPropertyValue:(mbgl::style::Function<float>)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = @(stop.second); + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithBoolPropertyValue:(mbgl::style::Function<bool>)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = @(stop.second); + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithStringPropertyValue:(mbgl::style::Function<std::string>)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = @(stop.second.c_str()); + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithOffsetPropertyValue:(mbgl::style::Function<std::array<float, 2> >)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = @[@(stop.second[0]), @(stop.second[1])]; + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithPaddingPropertyValue:(mbgl::style::Function<std::array<float, 4> >)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + convertedStops[@(stop.first)] = @[@(stop.second[0]), @(stop.second[1]), @(stop.second[2]), @(stop.second[3])]; + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithStringArrayPropertyValue:(mbgl::style::Function<std::vector<std::string> >)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + auto strings = stop.second; + NSMutableArray *convertedStrings = [NSMutableArray arrayWithCapacity:strings.size()]; + for (auto const& string: strings) { + [convertedStrings addObject:@(string.c_str())]; + } + convertedStops[@(stop.first)] = convertedStrings; + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + ++ (instancetype)functionWithNumberArrayPropertyValue:(mbgl::style::Function<std::vector<float> >)property +{ + MGLStyleAttributeFunction *function = [[MGLStyleAttributeFunction alloc] init]; + auto stops = property.getStops(); + NSMutableDictionary *convertedStops = [NSMutableDictionary dictionaryWithCapacity:stops.size()]; + for (auto stop : stops) { + auto numbers = stop.second; + NSMutableArray *convertedNumbers = [NSMutableArray arrayWithCapacity:numbers.size()]; + for (auto const& number: numbers) { + [convertedNumbers addObject:@(number)]; + } + convertedStops[@(stop.first)] = convertedNumbers; + } + function.base = @(property.getBase()); + function.stops = convertedStops; + return function; +} + +- (NSString *)description +{ + return [NSString stringWithFormat:@"<%@: %p, base = %@; stops = %@>", + NSStringFromClass([self class]), (void *)self, + self.base, + self.stops]; +} + +@end diff --git a/platform/darwin/src/MGLStyleAttributeFunction_Private.hpp b/platform/darwin/src/MGLStyleAttributeFunction_Private.hpp new file mode 100644 index 0000000000..a75e17483d --- /dev/null +++ b/platform/darwin/src/MGLStyleAttributeFunction_Private.hpp @@ -0,0 +1,61 @@ +#import "MGLStyleAttributeFunction.h" + +#include <mbgl/util/color.hpp> +#include <mbgl/style/function.hpp> +#include <mbgl/style/property_value.hpp> + +#define MGLSetEnumProperty(name, Name, MBGLType, ObjCType) \ + if (name.isFunction) { \ + NSAssert([name isKindOfClass:[MGLStyleAttributeFunction class]], @"" #name @" should be a function"); \ + \ + __block std::vector<std::pair<float, mbgl::style::MBGLType>> stops; \ + [[(MGLStyleAttributeFunction *)name stops] enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull key, NSValue * _Nonnull obj, BOOL * _Nonnull stop) { \ + NSAssert([obj isKindOfClass:[NSValue class]], @"Stops in " #name @" should be NSValues"); \ + ObjCType value; \ + [obj getValue:&value]; \ + stops.emplace_back(key.floatValue, static_cast<mbgl::style::MBGLType>(value)); \ + }]; \ + auto function = mbgl::style::Function<mbgl::style::MBGLType> { \ + stops, \ + [(MGLStyleAttributeFunction *)name base].floatValue, \ + }; \ + self.layer->set##Name(function); \ + } else { \ + NSAssert([name isKindOfClass:[NSValue class]], @"" #name @"should be an NSValue"); \ + ObjCType value; \ + [(NSValue *)name getValue:&value]; \ + self.layer->set##Name({ static_cast<mbgl::style::MBGLType>(value) }); \ + } + +#define MGLGetEnumProperty(Name, MBGLType, ObjCType) \ + const char *type = @encode(ObjCType); \ + mbgl::style::PropertyValue<mbgl::style::MBGLType> property = self.layer->get##Name(); \ + if (property.isConstant()) { \ + return [NSValue value:&property.asConstant() withObjCType:type]; \ + } else if (property.isFunction()) { \ + return nil; \ + } else { \ + return nil; \ + } + +@interface MGLStyleAttributeFunction(Private) + ++ (instancetype)functionWithColorPropertyValue:(mbgl::style::Function<mbgl::Color>)property; + ++ (instancetype)functionWithNumberPropertyValue:(mbgl::style::Function<float>)property; + ++ (instancetype)functionWithBoolPropertyValue:(mbgl::style::Function<bool>)property; + ++ (instancetype)functionWithStringPropertyValue:(mbgl::style::Function<std::string>)property; + ++ (instancetype)functionWithOffsetPropertyValue:(mbgl::style::Function<std::array<float, 2>>)property; + ++ (instancetype)functionWithPaddingPropertyValue:(mbgl::style::Function<std::array<float, 4>>)property; + ++ (instancetype)functionWithStringArrayPropertyValue:(mbgl::style::Function<std::vector<std::string>>)property; + ++ (instancetype)functionWithNumberArrayPropertyValue:(mbgl::style::Function<std::vector<float>>)property; + ++ (instancetype)functionWithEnumProperyValue:(mbgl::style::Function<bool>)property type:(const char *)type; + +@end; diff --git a/platform/darwin/src/MGLStyleAttributeValue.h b/platform/darwin/src/MGLStyleAttributeValue.h new file mode 100644 index 0000000000..31edccb14f --- /dev/null +++ b/platform/darwin/src/MGLStyleAttributeValue.h @@ -0,0 +1,7 @@ +#import <Foundation/Foundation.h> + +#import "MGLTypes.h" + +@protocol MGLStyleAttributeValue <NSObject> +@optional +@end
\ No newline at end of file diff --git a/platform/darwin/src/MGLStyleAttributeValue_Private.hpp b/platform/darwin/src/MGLStyleAttributeValue_Private.hpp new file mode 100644 index 0000000000..a3c8a1a149 --- /dev/null +++ b/platform/darwin/src/MGLStyleAttributeValue_Private.hpp @@ -0,0 +1,25 @@ +#import <Foundation/Foundation.h> + +#import "MGLTypes.h" +#import "MGLStyleAttributeFunction_Private.hpp" +#include <array> + +@protocol MGLStyleAttributeValue_Private <NSObject> +- (BOOL)isFunction; +@optional + +// Convert darwin types to mbgl types +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue; +- (mbgl::style::PropertyValue<float>)mbgl_floatPropertyValue; +- (mbgl::style::PropertyValue<bool>)mbgl_boolPropertyValue; +- (mbgl::style::PropertyValue<std::string>)mbgl_stringPropertyValue; +- (mbgl::style::PropertyValue<std::array<float, 2>>)mbgl_offsetPropertyValue; +- (mbgl::style::PropertyValue<std::array<float, 4>>)mbgl_paddingPropertyValue; +- (mbgl::style::PropertyValue<std::vector<std::string> >)mbgl_stringArrayPropertyValue; +- (mbgl::style::PropertyValue<std::vector<float> >)mbgl_numberArrayPropertyValue; +- (mbgl::style::PropertyValue<uint8_t>)mbgl_enumPropertyValue; + +// Convert mbgl types to darwin types +- (id <MGLStyleAttributeValue>)mbgl_colorPropertyValueWith:(mbgl::style::PropertyValue<mbgl::Color>)color; + +@end diff --git a/platform/darwin/src/MGLStyleFilter.h b/platform/darwin/src/MGLStyleFilter.h new file mode 100644 index 0000000000..29167f2248 --- /dev/null +++ b/platform/darwin/src/MGLStyleFilter.h @@ -0,0 +1,5 @@ +#import <Foundation/Foundation.h> + +@interface MGLStyleFilter : NSObject + +@end diff --git a/platform/darwin/src/MGLStyleFilter.m b/platform/darwin/src/MGLStyleFilter.m new file mode 100644 index 0000000000..8649a89d81 --- /dev/null +++ b/platform/darwin/src/MGLStyleFilter.m @@ -0,0 +1,5 @@ +#import "MGLStyleFilter.h" + +@implementation MGLStyleFilter + +@end diff --git a/platform/darwin/src/MGLStyleLayer.h b/platform/darwin/src/MGLStyleLayer.h new file mode 100644 index 0000000000..30456331db --- /dev/null +++ b/platform/darwin/src/MGLStyleLayer.h @@ -0,0 +1,17 @@ +#import <Foundation/Foundation.h> + +@class MGLMapView; + +@protocol MGLStyleLayer <NSObject> + +@property (nonatomic, weak) MGLMapView *mapView; +@property (nonatomic, copy, readonly) NSString *layerIdentifier; + +@optional + +@property (nonatomic, readonly) NSString *sourceIdentifier; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier; +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier; + +@end diff --git a/platform/darwin/src/MGLStyleLayer.h.ejs b/platform/darwin/src/MGLStyleLayer.h.ejs new file mode 100644 index 0000000000..629edba6c6 --- /dev/null +++ b/platform/darwin/src/MGLStyleLayer.h.ejs @@ -0,0 +1,55 @@ +<% + const type = locals.type; + const layoutProperties = locals.layoutProperties; + const paintProperties = locals.paintProperties; +-%> +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +<% for (const property of layoutProperties) { -%> +<% if (property.type == "enum") { -%> +typedef NS_ENUM(NSUInteger, MGL<%- camelize(type) %>StyleLayer<%- camelize(property.name) %>) { +<% for (const value of property.values) { -%> + MGL<%- camelize(type) %>StyleLayer<%- camelize(property.name) %><%- camelize(value) %>, +<% } -%> +}; + +<% } -%> +<% } -%> +<% for (const property of paintProperties) { -%> +<% if (property.type == "enum") { -%> +typedef NS_ENUM(NSUInteger, MGL<%- camelize(type) %>StyleLayer<%- camelize(property.name) %>) { +<% for (const value of property.values) { -%> + MGL<%- camelize(type) %>StyleLayer<%- camelize(property.name) %><%- camelize(value) %>, +<% } -%> +}; + +<% } -%> +<% } -%> +@interface MGL<%- camelize(type) %>StyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +<% if (layoutProperties.length) { -%> +#pragma mark - Accessing the Layout Attributes + +<% for (const property of layoutProperties) { -%> +/** + <%- property.doc %> + */ +@property (nonatomic) <%- propertyType(property, false, type) %> <%- camelizeWithLeadingLowercase(property.name) %>; + +<% } -%> +<% } -%> +#pragma mark - Accessing the Paint Attributes + +<% for (const property of paintProperties) { -%> +/** + <%- property.doc %> + */ +@property (nonatomic) <%- propertyType(property, false, type) %> <%- camelizeWithLeadingLowercase(property.name) %>; + +<% } -%> +@end diff --git a/platform/darwin/src/MGLStyleLayer.mm b/platform/darwin/src/MGLStyleLayer.mm new file mode 100644 index 0000000000..cacc11380a --- /dev/null +++ b/platform/darwin/src/MGLStyleLayer.mm @@ -0,0 +1,5 @@ +#import "MGLStyleLayer.h" + +#import "MGLTypes.h" +#import "MGLStyleLayer_Private.hpp" +#import "MGLMapView_Private.hpp" diff --git a/platform/darwin/src/MGLStyleLayer.mm.ejs b/platform/darwin/src/MGLStyleLayer.mm.ejs new file mode 100644 index 0000000000..c360898098 --- /dev/null +++ b/platform/darwin/src/MGLStyleLayer.mm.ejs @@ -0,0 +1,64 @@ +<% + const type = locals.type; + const layoutProperties = locals.layoutProperties; + const paintProperties = locals.paintProperties; +-%> +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGL<%- camelize(type) %>StyleLayer.h" + +#include <mbgl/style/layers/<%- type %>_layer.hpp> + +@interface MGL<%- camelize(type) %>StyleLayer () + +@property (nonatomic) mbgl::style::<%- camelize(type) %>Layer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGL<%- camelize(type) %>StyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + <%- initLayer(type) %> + } + return self; +} + +<% if (layoutProperties.length) { -%> +#pragma mark - Accessing the Layout Attributes + +<% for (const property of layoutProperties) { -%> +- (void)set<%- camelize(property.name) %>:(<%- propertyType(property, true, type) %>)<%- objCName(property) %> { + <%- setterImplementation(property, type) %> +} + +- (<%- propertyType(property, false, type) %>)<%- objCName(property) %> { + <%- getterImplementation(property, type) %> +} + +<% } -%> +<% } -%> +<% if (paintProperties.length) { -%> +#pragma mark - Accessing the Paint Attributes + +<% for (const property of paintProperties) { -%> +- (void)set<%- camelize(property.name) %>:(<%- propertyType(property, true, type) %>)<%- objCName(property) %> { + <%- setterImplementation(property, type) %> +} + +- (<%- propertyType(property, false, type) %>)<%- objCName(property) %> { + <%- getterImplementation(property, type) %> +} + +<% } -%> +<% } -%> +@end diff --git a/platform/darwin/src/MGLStyleLayer_Private.hpp b/platform/darwin/src/MGLStyleLayer_Private.hpp new file mode 100644 index 0000000000..b62093d321 --- /dev/null +++ b/platform/darwin/src/MGLStyleLayer_Private.hpp @@ -0,0 +1,30 @@ +#import <Foundation/Foundation.h> +#include <mbgl/style/layer.hpp> + +#import "MGLStyleLayer.h" +#import "MGLStyleAttribute.hpp" + +#import "NSNumber+MGLStyleAttributeAdditions_Private.hpp" +#import "NSArray+MGLStyleAttributeAdditions_Private.hpp" +#import "NSString+MGLStyleAttributeAdditions_Private.hpp" +#import "NSValue+MGLStyleAttributeAdditions_Private.hpp" +#import "MGLStyleAttributeFunction_Private.hpp" +#import "MGLStyleAttributeValue_Private.hpp" + +#if TARGET_OS_IPHONE +#import "UIColor+MGLAdditions.hpp" +#import "UIColor+MGLStyleAttributeAdditions_Private.hpp" +#else +#import "NSColor+MGLAdditions.hpp" +#import "NSColor+MGLStyleAttributeAdditions_Private.hpp" +#endif + +@class MGLMapView; + +@protocol MGLStyleLayer_Private <MGLStyleLayer> + +@property (nonatomic, weak) MGLMapView *mapView; +@property (nonatomic, readwrite, copy) NSString *layerIdentifier; +@property (nonatomic) mbgl::style::Layer *layer; + +@end diff --git a/platform/darwin/src/MGLStyle_Private.hpp b/platform/darwin/src/MGLStyle_Private.hpp new file mode 100644 index 0000000000..ed0122bf73 --- /dev/null +++ b/platform/darwin/src/MGLStyle_Private.hpp @@ -0,0 +1,10 @@ +#import "MGLStyle.h" + +#import "MGLStyleLayer.h" +#import "MGLFillStyleLayer.h" +#import <mbgl/util/default_styles.hpp> +#include <mbgl/mbgl.hpp> + +@interface MGLStyle (Private) +@property (nonatomic, weak) MGLMapView *mapView; +@end diff --git a/platform/darwin/src/MGLSymbolStyleLayer.h b/platform/darwin/src/MGLSymbolStyleLayer.h new file mode 100644 index 0000000000..1f3568890b --- /dev/null +++ b/platform/darwin/src/MGLSymbolStyleLayer.h @@ -0,0 +1,315 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLTypes.h" +#import "MGLStyleAttributeValue.h" +#import "MGLBaseStyleLayer.h" + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerSymbolPlacement) { + MGLSymbolStyleLayerSymbolPlacementPoint, + MGLSymbolStyleLayerSymbolPlacementLine, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerIconRotationAlignment) { + MGLSymbolStyleLayerIconRotationAlignmentMap, + MGLSymbolStyleLayerIconRotationAlignmentViewport, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerIconTextFit) { + MGLSymbolStyleLayerIconTextFitNone, + MGLSymbolStyleLayerIconTextFitBoth, + MGLSymbolStyleLayerIconTextFitWidth, + MGLSymbolStyleLayerIconTextFitHeight, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextPitchAlignment) { + MGLSymbolStyleLayerTextPitchAlignmentMap, + MGLSymbolStyleLayerTextPitchAlignmentViewport, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextRotationAlignment) { + MGLSymbolStyleLayerTextRotationAlignmentMap, + MGLSymbolStyleLayerTextRotationAlignmentViewport, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextJustify) { + MGLSymbolStyleLayerTextJustifyLeft, + MGLSymbolStyleLayerTextJustifyCenter, + MGLSymbolStyleLayerTextJustifyRight, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextAnchor) { + MGLSymbolStyleLayerTextAnchorCenter, + MGLSymbolStyleLayerTextAnchorLeft, + MGLSymbolStyleLayerTextAnchorRight, + MGLSymbolStyleLayerTextAnchorTop, + MGLSymbolStyleLayerTextAnchorBottom, + MGLSymbolStyleLayerTextAnchorTopLeft, + MGLSymbolStyleLayerTextAnchorTopRight, + MGLSymbolStyleLayerTextAnchorBottomLeft, + MGLSymbolStyleLayerTextAnchorBottomRight, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextTransform) { + MGLSymbolStyleLayerTextTransformNone, + MGLSymbolStyleLayerTextTransformUppercase, + MGLSymbolStyleLayerTextTransformLowercase, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerIconTranslateAnchor) { + MGLSymbolStyleLayerIconTranslateAnchorMap, + MGLSymbolStyleLayerIconTranslateAnchorViewport, +}; + +typedef NS_ENUM(NSUInteger, MGLSymbolStyleLayerTextTranslateAnchor) { + MGLSymbolStyleLayerTextTranslateAnchorMap, + MGLSymbolStyleLayerTextTranslateAnchorViewport, +}; + +@interface MGLSymbolStyleLayer : MGLBaseStyleLayer <MGLStyleLayer> + +#pragma mark - Accessing the Layout Attributes + +/** + Label placement relative to its geometry. `line` can only be used on LineStrings and Polygons. + */ +@property (nonatomic) id <MGLStyleAttributeValue> symbolPlacement; + +/** + Distance between two symbol anchors. + */ +@property (nonatomic) id <MGLStyleAttributeValue> symbolSpacing; + +/** + If true, the symbols will not cross tile edges to avoid mutual collisions. Recommended in layers that don't have enough padding in the vector tile to prevent collisions, or if it is a point symbol layer placed after a line symbol layer. + */ +@property (nonatomic) id <MGLStyleAttributeValue> symbolAvoidEdges; + +/** + If true, the icon will be visible even if it collides with other previously drawn symbols. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconAllowOverlap; + +/** + If true, other symbols can be visible even if they collide with the icon. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconIgnorePlacement; + +/** + If true, text will display without their corresponding icons when the icon collides with other symbols and the text does not. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconOptional; + +/** + Orientation of icon when map is rotated. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconRotationAlignment; + +/** + Scale factor for icon. 1 is original size, 3 triples the size. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconSize; + +/** + Position and scale an icon by the its corresponding text. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconTextFit; + +/** + Size of padding area around the text-fit size in clockwise order: top, right, bottom, left. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconTextFitPadding; + +/** + A string with {tokens} replaced, referencing the data property to pull from. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconImage; + +/** + Rotates the icon clockwise. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconRotate; + +/** + Size of the additional area around the icon bounding box used for detecting symbol collisions. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconPadding; + +/** + If true, the icon may be flipped to prevent it from being rendered upside-down. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconKeepUpright; + +/** + Offset distance of icon from its anchor. Positive values indicate right and down, while negative values indicate left and up. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconOffset; + +/** + Aligns text to the plane of the `viewport` or the `map` when the map is pitched. Matches `text-rotation-alignment` if unspecified. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textPitchAlignment; + +/** + Orientation of text when map is rotated. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textRotationAlignment; + +/** + Value to use for a text label. Feature properties are specified using tokens like {field_name}. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textField; + +/** + Font stack to use for displaying text. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textFont; + +/** + Font size. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textSize; + +/** + The maximum line width for text wrapping. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textMaxWidth; + +/** + Text leading value for multi-line text. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textLineHeight; + +/** + Text tracking amount. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textLetterSpacing; + +/** + Text justification options. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textJustify; + +/** + Part of the text placed closest to the anchor. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textAnchor; + +/** + Maximum angle change between adjacent characters. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textMaxAngle; + +/** + Rotates the text clockwise. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textRotate; + +/** + Size of the additional area around the text bounding box used for detecting symbol collisions. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textPadding; + +/** + If true, the text may be flipped vertically to prevent it from being rendered upside-down. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textKeepUpright; + +/** + Specifies how to capitalize text, similar to the CSS `text-transform` property. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textTransform; + +/** + Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textOffset; + +/** + If true, the text will be visible even if it collides with other previously drawn symbols. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textAllowOverlap; + +/** + If true, other symbols can be visible even if they collide with the text. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textIgnorePlacement; + +/** + If true, icons will display without their corresponding text when the text collides with other symbols and the icon does not. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textOptional; + +#pragma mark - Accessing the Paint Attributes + +/** + The opacity at which the icon will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconOpacity; + +/** + The color of the icon. This can only be used with sdf icons. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconColor; + +/** + The color of the icon's halo. Icon halos can only be used with sdf icons. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconHaloColor; + +/** + Distance of halo to the icon outline. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconHaloWidth; + +/** + Fade out the halo towards the outside. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconHaloBlur; + +/** + Distance that the icon's anchor is moved from its original placement. Positive values indicate right and down, while negative values indicate left and up. + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconTranslate; + +/** + Control whether the translation is relative to the map (north) or viewport (screen). + */ +@property (nonatomic) id <MGLStyleAttributeValue> iconTranslateAnchor; + +/** + The opacity at which the text will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textOpacity; + +/** + The color with which the text will be drawn. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textColor; + +/** + The color of the text's halo, which helps it stand out from backgrounds. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textHaloColor; + +/** + Distance of halo to the font outline. Max text halo width is 1/4 of the font-size. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textHaloWidth; + +/** + The halo's fadeout distance towards the outside. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textHaloBlur; + +/** + Distance that the text's anchor is moved from its original placement. Positive values indicate right and down, while negative values indicate left and up. + */ +@property (nonatomic) id <MGLStyleAttributeValue> textTranslate; + +/** + Control whether the translation is relative to the map (north) or viewport (screen). + */ +@property (nonatomic) id <MGLStyleAttributeValue> textTranslateAnchor; + +@end diff --git a/platform/darwin/src/MGLSymbolStyleLayer.mm b/platform/darwin/src/MGLSymbolStyleLayer.mm new file mode 100644 index 0000000000..335d0bfc6c --- /dev/null +++ b/platform/darwin/src/MGLSymbolStyleLayer.mm @@ -0,0 +1,419 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayer_Private.hpp" +#import "MGLStyleAttributeValue.h" +#import "MGLSymbolStyleLayer.h" + +#include <mbgl/style/layers/symbol_layer.hpp> + +@interface MGLSymbolStyleLayer () + +@property (nonatomic) mbgl::style::SymbolLayer *layer; +@property (nonatomic, readwrite) NSString *layerIdentifier; +@property (nonatomic, readwrite) NSString *sourceIdentifier; + +@end + +@implementation MGLSymbolStyleLayer + +@synthesize mapView; + +- (instancetype)initWithLayerIdentifier:(NSString *)layerIdentifier sourceIdentifier:(NSString *)sourceIdentifier { + if (self = [super init]) { + _layerIdentifier = layerIdentifier; + _sourceIdentifier = sourceIdentifier; + _layer = new mbgl::style::SymbolLayer(layerIdentifier.UTF8String, sourceIdentifier.UTF8String); + } + return self; +} + +#pragma mark - Accessing the Layout Attributes + +- (void)setSymbolPlacement:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)symbolPlacement { + MGLSetEnumProperty(symbolPlacement, SymbolPlacement, SymbolPlacementType, MGLSymbolStyleLayerSymbolPlacement); +} + +- (id <MGLStyleAttributeValue>)symbolPlacement { + MGLGetEnumProperty(SymbolPlacement, SymbolPlacementType, MGLSymbolStyleLayerSymbolPlacement); +} + +- (void)setSymbolSpacing:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)symbolSpacing { + self.layer->setSymbolSpacing(symbolSpacing.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)symbolSpacing { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getSymbolSpacing()]; +} + +- (void)setSymbolAvoidEdges:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)symbolAvoidEdges { + self.layer->setSymbolAvoidEdges(symbolAvoidEdges.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)symbolAvoidEdges { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getSymbolAvoidEdges()]; +} + +- (void)setIconAllowOverlap:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconAllowOverlap { + self.layer->setIconAllowOverlap(iconAllowOverlap.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconAllowOverlap { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getIconAllowOverlap()]; +} + +- (void)setIconIgnorePlacement:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconIgnorePlacement { + self.layer->setIconIgnorePlacement(iconIgnorePlacement.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconIgnorePlacement { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getIconIgnorePlacement()]; +} + +- (void)setIconOptional:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconOptional { + self.layer->setIconOptional(iconOptional.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconOptional { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getIconOptional()]; +} + +- (void)setIconRotationAlignment:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconRotationAlignment { + MGLSetEnumProperty(iconRotationAlignment, IconRotationAlignment, AlignmentType, MGLSymbolStyleLayerIconRotationAlignment); +} + +- (id <MGLStyleAttributeValue>)iconRotationAlignment { + MGLGetEnumProperty(IconRotationAlignment, AlignmentType, MGLSymbolStyleLayerIconRotationAlignment); +} + +- (void)setIconSize:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconSize { + self.layer->setIconSize(iconSize.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconSize { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconSize()]; +} + +- (void)setIconTextFit:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconTextFit { + MGLSetEnumProperty(iconTextFit, IconTextFit, IconTextFitType, MGLSymbolStyleLayerIconTextFit); +} + +- (id <MGLStyleAttributeValue>)iconTextFit { + MGLGetEnumProperty(IconTextFit, IconTextFitType, MGLSymbolStyleLayerIconTextFit); +} + +- (void)setIconTextFitPadding:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconTextFitPadding { + self.layer->setIconTextFitPadding(iconTextFitPadding.mbgl_paddingPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconTextFitPadding { + return [MGLStyleAttribute mbgl_paddingPropertyValueWith:self.layer->getIconTextFitPadding()]; +} + +- (void)setIconImage:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconImage { + self.layer->setIconImage(iconImage.mbgl_stringPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconImage { + return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->getIconImage()]; +} + +- (void)setIconRotate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconRotate { + self.layer->setIconRotate(iconRotate.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconRotate { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconRotate()]; +} + +- (void)setIconPadding:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconPadding { + self.layer->setIconPadding(iconPadding.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconPadding { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconPadding()]; +} + +- (void)setIconKeepUpright:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconKeepUpright { + self.layer->setIconKeepUpright(iconKeepUpright.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconKeepUpright { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getIconKeepUpright()]; +} + +- (void)setIconOffset:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconOffset { + self.layer->setIconOffset(iconOffset.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconOffset { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getIconOffset()]; +} + +- (void)setTextPitchAlignment:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textPitchAlignment { + MGLSetEnumProperty(textPitchAlignment, TextPitchAlignment, AlignmentType, MGLSymbolStyleLayerTextPitchAlignment); +} + +- (id <MGLStyleAttributeValue>)textPitchAlignment { + MGLGetEnumProperty(TextPitchAlignment, AlignmentType, MGLSymbolStyleLayerTextPitchAlignment); +} + +- (void)setTextRotationAlignment:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textRotationAlignment { + MGLSetEnumProperty(textRotationAlignment, TextRotationAlignment, AlignmentType, MGLSymbolStyleLayerTextRotationAlignment); +} + +- (id <MGLStyleAttributeValue>)textRotationAlignment { + MGLGetEnumProperty(TextRotationAlignment, AlignmentType, MGLSymbolStyleLayerTextRotationAlignment); +} + +- (void)setTextField:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textField { + self.layer->setTextField(textField.mbgl_stringPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textField { + return [MGLStyleAttribute mbgl_stringPropertyValueWith:self.layer->getTextField()]; +} + +- (void)setTextFont:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textFont { + self.layer->setTextFont(textFont.mbgl_stringArrayPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textFont { + return [MGLStyleAttribute mbgl_stringArrayPropertyValueWith:self.layer->getTextFont()]; +} + +- (void)setTextSize:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textSize { + self.layer->setTextSize(textSize.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textSize { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextSize()]; +} + +- (void)setTextMaxWidth:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textMaxWidth { + self.layer->setTextMaxWidth(textMaxWidth.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textMaxWidth { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextMaxWidth()]; +} + +- (void)setTextLineHeight:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textLineHeight { + self.layer->setTextLineHeight(textLineHeight.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textLineHeight { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextLineHeight()]; +} + +- (void)setTextLetterSpacing:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textLetterSpacing { + self.layer->setTextLetterSpacing(textLetterSpacing.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textLetterSpacing { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextLetterSpacing()]; +} + +- (void)setTextJustify:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textJustify { + MGLSetEnumProperty(textJustify, TextJustify, TextJustifyType, MGLSymbolStyleLayerTextJustify); +} + +- (id <MGLStyleAttributeValue>)textJustify { + MGLGetEnumProperty(TextJustify, TextJustifyType, MGLSymbolStyleLayerTextJustify); +} + +- (void)setTextAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textAnchor { + MGLSetEnumProperty(textAnchor, TextAnchor, TextAnchorType, MGLSymbolStyleLayerTextAnchor); +} + +- (id <MGLStyleAttributeValue>)textAnchor { + MGLGetEnumProperty(TextAnchor, TextAnchorType, MGLSymbolStyleLayerTextAnchor); +} + +- (void)setTextMaxAngle:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textMaxAngle { + self.layer->setTextMaxAngle(textMaxAngle.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textMaxAngle { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextMaxAngle()]; +} + +- (void)setTextRotate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textRotate { + self.layer->setTextRotate(textRotate.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textRotate { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextRotate()]; +} + +- (void)setTextPadding:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textPadding { + self.layer->setTextPadding(textPadding.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textPadding { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextPadding()]; +} + +- (void)setTextKeepUpright:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textKeepUpright { + self.layer->setTextKeepUpright(textKeepUpright.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textKeepUpright { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getTextKeepUpright()]; +} + +- (void)setTextTransform:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textTransform { + MGLSetEnumProperty(textTransform, TextTransform, TextTransformType, MGLSymbolStyleLayerTextTransform); +} + +- (id <MGLStyleAttributeValue>)textTransform { + MGLGetEnumProperty(TextTransform, TextTransformType, MGLSymbolStyleLayerTextTransform); +} + +- (void)setTextOffset:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textOffset { + self.layer->setTextOffset(textOffset.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textOffset { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getTextOffset()]; +} + +- (void)setTextAllowOverlap:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textAllowOverlap { + self.layer->setTextAllowOverlap(textAllowOverlap.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textAllowOverlap { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getTextAllowOverlap()]; +} + +- (void)setTextIgnorePlacement:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textIgnorePlacement { + self.layer->setTextIgnorePlacement(textIgnorePlacement.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textIgnorePlacement { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getTextIgnorePlacement()]; +} + +- (void)setTextOptional:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textOptional { + self.layer->setTextOptional(textOptional.mbgl_boolPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textOptional { + return [MGLStyleAttribute mbgl_boolPropertyValueWith:self.layer->getTextOptional()]; +} + +#pragma mark - Accessing the Paint Attributes + +- (void)setIconOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconOpacity { + self.layer->setIconOpacity(iconOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconOpacity()]; +} + +- (void)setIconColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconColor { + self.layer->setIconColor(iconColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getIconColor()]; +} + +- (void)setIconHaloColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconHaloColor { + self.layer->setIconHaloColor(iconHaloColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconHaloColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getIconHaloColor()]; +} + +- (void)setIconHaloWidth:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconHaloWidth { + self.layer->setIconHaloWidth(iconHaloWidth.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconHaloWidth { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconHaloWidth()]; +} + +- (void)setIconHaloBlur:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconHaloBlur { + self.layer->setIconHaloBlur(iconHaloBlur.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconHaloBlur { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getIconHaloBlur()]; +} + +- (void)setIconTranslate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconTranslate { + self.layer->setIconTranslate(iconTranslate.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)iconTranslate { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getIconTranslate()]; +} + +- (void)setIconTranslateAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)iconTranslateAnchor { + MGLSetEnumProperty(iconTranslateAnchor, IconTranslateAnchor, TranslateAnchorType, MGLSymbolStyleLayerIconTranslateAnchor); +} + +- (id <MGLStyleAttributeValue>)iconTranslateAnchor { + MGLGetEnumProperty(IconTranslateAnchor, TranslateAnchorType, MGLSymbolStyleLayerIconTranslateAnchor); +} + +- (void)setTextOpacity:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textOpacity { + self.layer->setTextOpacity(textOpacity.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textOpacity { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextOpacity()]; +} + +- (void)setTextColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textColor { + self.layer->setTextColor(textColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getTextColor()]; +} + +- (void)setTextHaloColor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textHaloColor { + self.layer->setTextHaloColor(textHaloColor.mbgl_colorPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textHaloColor { + return [MGLStyleAttribute mbgl_colorPropertyValueWith:self.layer->getTextHaloColor()]; +} + +- (void)setTextHaloWidth:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textHaloWidth { + self.layer->setTextHaloWidth(textHaloWidth.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textHaloWidth { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextHaloWidth()]; +} + +- (void)setTextHaloBlur:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textHaloBlur { + self.layer->setTextHaloBlur(textHaloBlur.mbgl_floatPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textHaloBlur { + return [MGLStyleAttribute mbgl_numberPropertyValueWith:self.layer->getTextHaloBlur()]; +} + +- (void)setTextTranslate:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textTranslate { + self.layer->setTextTranslate(textTranslate.mbgl_offsetPropertyValue); +} + +- (id <MGLStyleAttributeValue>)textTranslate { + return [MGLStyleAttribute mbgl_offsetPropertyValueWith:self.layer->getTextTranslate()]; +} + +- (void)setTextTranslateAnchor:(id <MGLStyleAttributeValue, MGLStyleAttributeValue_Private>)textTranslateAnchor { + MGLSetEnumProperty(textTranslateAnchor, TextTranslateAnchor, TranslateAnchorType, MGLSymbolStyleLayerTextTranslateAnchor); +} + +- (id <MGLStyleAttributeValue>)textTranslateAnchor { + MGLGetEnumProperty(TextTranslateAnchor, TranslateAnchorType, MGLSymbolStyleLayerTextTranslateAnchor); +} + +@end diff --git a/platform/darwin/src/MGLTypes.h b/platform/darwin/src/MGLTypes.h index 2579451f2d..f63c602a53 100644 --- a/platform/darwin/src/MGLTypes.h +++ b/platform/darwin/src/MGLTypes.h @@ -12,6 +12,14 @@ #define _Nonnull #endif +#if TARGET_OS_IPHONE +@class UIColor; +#define MGLColor UIColor +#else +@class NSColor; +#define MGLColor NSColor +#endif + NS_ASSUME_NONNULL_BEGIN /** Indicates an error occurred in the Mapbox SDK. */ diff --git a/platform/darwin/src/MGLVectorSource.h b/platform/darwin/src/MGLVectorSource.h new file mode 100644 index 0000000000..28322e289e --- /dev/null +++ b/platform/darwin/src/MGLVectorSource.h @@ -0,0 +1,5 @@ +#import "MGLSource.h" + +@interface MGLVectorSource : MGLSource + +@end diff --git a/platform/darwin/src/MGLVectorSource.m b/platform/darwin/src/MGLVectorSource.m new file mode 100644 index 0000000000..4d7918f5f7 --- /dev/null +++ b/platform/darwin/src/MGLVectorSource.m @@ -0,0 +1,5 @@ +#import "MGLVectorSource.h" + +@implementation MGLVectorSource + +@end diff --git a/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.h b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..fa5193acf0 --- /dev/null +++ b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +@interface NSArray (MGLStyleAttributeAdditions) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.mm b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.mm new file mode 100644 index 0000000000..c0c9a4027a --- /dev/null +++ b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions.mm @@ -0,0 +1,54 @@ +#import "NSArray+MGLStyleAttributeAdditions.h" + +#import "NSArray+MGLStyleAttributeAdditions_Private.hpp" +#import "MGLStyleAttributeValue_Private.hpp" + +#include <array> + +@interface NSArray(Private) <MGLStyleAttributeValue_Private> +@end + +@implementation NSArray (MGLStyleAttributeAdditions) + +- (mbgl::style::PropertyValue<std::array<float, 2>>)mbgl_offsetPropertyValue +{ + NSAssert(self.count == 2, @"Offset must contain 2 values (dx, dy)"); + NSNumber *dx = self[0]; + NSNumber *dy = self[1]; + return {{dx.floatValue, dy.floatValue}}; +} + +- (mbgl::style::PropertyValue<std::array<float, 4> >)mbgl_paddingPropertyValue +{ + NSAssert(self.count == 4, @"Padding must contain 4 values (top, left, bottom & right)"); + NSNumber *top = self[0]; + NSNumber *left = self[1]; + NSNumber *bottom = self[2]; + NSNumber *right = self[3]; + return {{top.floatValue, left.floatValue, bottom.floatValue, right.floatValue}}; +} + +- (mbgl::style::PropertyValue<std::vector<std::string> >)mbgl_stringArrayPropertyValue +{ + std::vector<std::string>fonts; + + for (NSString *font in self) { + fonts.emplace_back(font.UTF8String); + } + + return {{fonts}}; +} + +- (mbgl::style::PropertyValue<std::vector<float> >)mbgl_numberArrayPropertyValue +{ + std::vector<float>values; + + for (NSNumber *n in self) { + values.emplace_back(n.floatValue); + } + + return {{values}}; +} + + +@end diff --git a/platform/darwin/src/NSArray+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..1be02c01d2 --- /dev/null +++ b/platform/darwin/src/NSArray+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,9 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface NSArray (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.h b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..5a4f7af006 --- /dev/null +++ b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <Cocoa/Cocoa.h> + +#import "MGLStyleAttributeValue.h" + +@interface NSColor (MGLStyleAttributeAdditions) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.m b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.m new file mode 100644 index 0000000000..ac330343c8 --- /dev/null +++ b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions.m @@ -0,0 +1,5 @@ +#import "NSColor+MGLStyleAttributeAdditions.h" + +@implementation NSColor (MGLStyleAttributeAdditions) + +@end diff --git a/platform/darwin/src/NSColor+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..9a714cbd83 --- /dev/null +++ b/platform/darwin/src/NSColor+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,9 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface NSColor (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.h b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..162b5e94f5 --- /dev/null +++ b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +@interface NSNumber (MGLStyleAttributeAdditions) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.mm b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.mm new file mode 100644 index 0000000000..163105d2fa --- /dev/null +++ b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions.mm @@ -0,0 +1,22 @@ +#import "NSNumber+MGLStyleAttributeAdditions.h" + +#include <mbgl/style/property_value.hpp> + +@implementation NSNumber (MGLStyleAttributeAdditions) + +- (NSNumber *)numberValue +{ + return self; +} + +- (mbgl::style::PropertyValue<bool>)mbgl_boolPropertyValue +{ + return mbgl::style::PropertyValue<bool> { !!self.boolValue }; +} + +- (mbgl::style::PropertyValue<float>)mbgl_floatPropertyValue +{ + return mbgl::style::PropertyValue<float> { self.floatValue }; +} + +@end diff --git a/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..73e40bb3ad --- /dev/null +++ b/platform/darwin/src/NSNumber+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,13 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface NSNumber (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> + +- (mbgl::style::PropertyValue<bool>)mbgl_booleanPropertyValue; + +- (mbgl::style::PropertyValue<float>)mbgl_numberPropertyValue; + +@end diff --git a/platform/darwin/src/NSString+MGLStyleAttributeAdditions.h b/platform/darwin/src/NSString+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..2126335922 --- /dev/null +++ b/platform/darwin/src/NSString+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +@interface NSString (MGLStyleAttributeAdditions) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSString+MGLStyleAttributeAdditions.mm b/platform/darwin/src/NSString+MGLStyleAttributeAdditions.mm new file mode 100644 index 0000000000..84453217ab --- /dev/null +++ b/platform/darwin/src/NSString+MGLStyleAttributeAdditions.mm @@ -0,0 +1,17 @@ +#import "NSString+MGLStyleAttributeAdditions.h" + +#import "NSString+MGLStyleAttributeAdditions_Private.hpp" + +@implementation NSString (MGLStyleAttributeAdditions) + +- (BOOL)isFunction +{ + return NO; +} + +- (mbgl::style::PropertyValue<std::string>)mbgl_stringPropertyValue +{ + return mbgl::style::PropertyValue<std::string> {{ self.UTF8String }}; +} + +@end diff --git a/platform/darwin/src/NSString+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/NSString+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..8e401e2996 --- /dev/null +++ b/platform/darwin/src/NSString+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,11 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface NSString (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> + +- (mbgl::style::PropertyValue<std::string>)mbgl_stringPropertyValue; + +@end diff --git a/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.h b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..0ee0c78f87 --- /dev/null +++ b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +@interface NSValue (MGLStyleAttributeValue) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.mm b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.mm new file mode 100644 index 0000000000..3349ca211f --- /dev/null +++ b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions.mm @@ -0,0 +1,19 @@ +#import "NSValue+MGLStyleAttributeAdditions.h" + +#import "NSValue+MGLStyleAttributeAdditions_Private.hpp" + +@implementation NSValue (MGLStyleAttributeAdditions) + +- (BOOL)isFunction +{ + return NO; +} + +- (mbgl::style::PropertyValue<uint8_t>)mbgl_enumPropertyValue +{ + uint8_t value = 0; + [self getValue:&value]; + return mbgl::style::PropertyValue<uint8_t> { value }; +} + +@end diff --git a/platform/darwin/src/NSValue+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..5bca9407ac --- /dev/null +++ b/platform/darwin/src/NSValue+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,9 @@ +#import <Foundation/Foundation.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface NSValue (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> +- (mbgl::style::PropertyValue<uint8_t>)mbgl_enumPropertyValue; +@end diff --git a/platform/darwin/src/UIColor+MGLStyleAttributeAdditions_Private.hpp b/platform/darwin/src/UIColor+MGLStyleAttributeAdditions_Private.hpp new file mode 100644 index 0000000000..ef886dca5d --- /dev/null +++ b/platform/darwin/src/UIColor+MGLStyleAttributeAdditions_Private.hpp @@ -0,0 +1,9 @@ +#import <UIKit/UIKit.h> + +#import "MGLStyleAttributeValue.h" + +#include <mbgl/style/property_value.hpp> + +@interface UIColor (MGLStyleAttributeAdditions_Private) <MGLStyleAttributeValue> + +@end diff --git a/platform/darwin/test/MGLBackgroundStyleLayerTests.m b/platform/darwin/test/MGLBackgroundStyleLayerTests.m new file mode 100644 index 0000000000..e36ca53022 --- /dev/null +++ b/platform/darwin/test/MGLBackgroundStyleLayerTests.m @@ -0,0 +1,29 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLBackgroundLayerTests : MGLStyleLayerTests +@end + +@implementation MGLBackgroundLayerTests + +- (void)testBackgroundLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLBackgroundStyleLayer *layer = [[MGLBackgroundStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.backgroundColor = MGLRuntimeStylingHelper.testColor; + layer.backgroundPattern = MGLRuntimeStylingHelper.testString; + layer.backgroundOpacity = MGLRuntimeStylingHelper.testNumber; + + MGLBackgroundStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssertEqualObjects(gLayer.backgroundColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.backgroundPattern, MGLRuntimeStylingHelper.testString); + XCTAssertEqualObjects(gLayer.backgroundOpacity, MGLRuntimeStylingHelper.testNumber); +} + +@end diff --git a/platform/darwin/test/MGLCircleStyleLayerTests.m b/platform/darwin/test/MGLCircleStyleLayerTests.m new file mode 100644 index 0000000000..f7ebcf822a --- /dev/null +++ b/platform/darwin/test/MGLCircleStyleLayerTests.m @@ -0,0 +1,37 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLCircleLayerTests : MGLStyleLayerTests +@end + +@implementation MGLCircleLayerTests + +- (void)testCircleLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLCircleStyleLayer *layer = [[MGLCircleStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.circleRadius = MGLRuntimeStylingHelper.testNumber; + layer.circleColor = MGLRuntimeStylingHelper.testColor; + layer.circleBlur = MGLRuntimeStylingHelper.testNumber; + layer.circleOpacity = MGLRuntimeStylingHelper.testNumber; + layer.circleTranslate = MGLRuntimeStylingHelper.testOffset; + layer.circleTranslateAnchor = [MGLRuntimeStylingHelper testEnum:MGLCircleStyleLayerCircleTranslateAnchorViewport type:@encode(MGLCircleStyleLayerCircleTranslateAnchor)]; + layer.circlePitchScale = [MGLRuntimeStylingHelper testEnum:MGLCircleStyleLayerCirclePitchScaleViewport type:@encode(MGLCircleStyleLayerCirclePitchScale)]; + + MGLCircleStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssertEqualObjects(gLayer.circleRadius, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.circleColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.circleBlur, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.circleOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.circleTranslate, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.circleTranslateAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLCircleStyleLayerCircleTranslateAnchorViewport type:@encode(MGLCircleStyleLayerCircleTranslateAnchor)] objCType]); + XCTAssert([(NSValue *)gLayer.circlePitchScale objCType] == [[MGLRuntimeStylingHelper testEnum:MGLCircleStyleLayerCirclePitchScaleViewport type:@encode(MGLCircleStyleLayerCirclePitchScale)] objCType]); +} + +@end diff --git a/platform/darwin/test/MGLFillStyleLayerTests.m b/platform/darwin/test/MGLFillStyleLayerTests.m new file mode 100644 index 0000000000..5a03d96354 --- /dev/null +++ b/platform/darwin/test/MGLFillStyleLayerTests.m @@ -0,0 +1,37 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLFillLayerTests : MGLStyleLayerTests +@end + +@implementation MGLFillLayerTests + +- (void)testFillLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLFillStyleLayer *layer = [[MGLFillStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.fillAntialias = MGLRuntimeStylingHelper.testBool; + layer.fillOpacity = MGLRuntimeStylingHelper.testNumber; + layer.fillColor = MGLRuntimeStylingHelper.testColor; + layer.fillOutlineColor = MGLRuntimeStylingHelper.testColor; + layer.fillTranslate = MGLRuntimeStylingHelper.testOffset; + layer.fillTranslateAnchor = [MGLRuntimeStylingHelper testEnum:MGLFillStyleLayerFillTranslateAnchorViewport type:@encode(MGLFillStyleLayerFillTranslateAnchor)]; + layer.fillPattern = MGLRuntimeStylingHelper.testString; + + MGLFillStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssertEqualObjects(gLayer.fillAntialias, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.fillOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.fillColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.fillOutlineColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.fillTranslate, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.fillTranslateAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLFillStyleLayerFillTranslateAnchorViewport type:@encode(MGLFillStyleLayerFillTranslateAnchor)] objCType]); + XCTAssertEqualObjects(gLayer.fillPattern, MGLRuntimeStylingHelper.testString); +} + +@end diff --git a/platform/darwin/test/MGLLineStyleLayerTests.m b/platform/darwin/test/MGLLineStyleLayerTests.m new file mode 100644 index 0000000000..0864c68ccd --- /dev/null +++ b/platform/darwin/test/MGLLineStyleLayerTests.m @@ -0,0 +1,51 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLLineLayerTests : MGLStyleLayerTests +@end + +@implementation MGLLineLayerTests + +- (void)testLineLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLLineStyleLayer *layer = [[MGLLineStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.lineCap = [MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineCapSquare type:@encode(MGLLineStyleLayerLineCap)]; + layer.lineJoin = [MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineJoinMiter type:@encode(MGLLineStyleLayerLineJoin)]; + layer.lineMiterLimit = MGLRuntimeStylingHelper.testNumber; + layer.lineRoundLimit = MGLRuntimeStylingHelper.testNumber; + layer.lineOpacity = MGLRuntimeStylingHelper.testNumber; + layer.lineColor = MGLRuntimeStylingHelper.testColor; + layer.lineTranslate = MGLRuntimeStylingHelper.testOffset; + layer.lineTranslateAnchor = [MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineTranslateAnchorViewport type:@encode(MGLLineStyleLayerLineTranslateAnchor)]; + layer.lineWidth = MGLRuntimeStylingHelper.testNumber; + layer.lineGapWidth = MGLRuntimeStylingHelper.testNumber; + layer.lineOffset = MGLRuntimeStylingHelper.testNumber; + layer.lineBlur = MGLRuntimeStylingHelper.testNumber; + layer.lineDasharray = MGLRuntimeStylingHelper.testDashArray; + layer.linePattern = MGLRuntimeStylingHelper.testString; + + MGLLineStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssert([(NSValue *)gLayer.lineCap objCType] == [[MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineCapSquare type:@encode(MGLLineStyleLayerLineCap)] objCType]); + XCTAssert([(NSValue *)gLayer.lineJoin objCType] == [[MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineJoinMiter type:@encode(MGLLineStyleLayerLineJoin)] objCType]); + XCTAssertEqualObjects(gLayer.lineMiterLimit, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineRoundLimit, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.lineTranslate, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.lineTranslateAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLLineStyleLayerLineTranslateAnchorViewport type:@encode(MGLLineStyleLayerLineTranslateAnchor)] objCType]); + XCTAssertEqualObjects(gLayer.lineWidth, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineGapWidth, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineOffset, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineBlur, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.lineDasharray, MGLRuntimeStylingHelper.testDashArray); + XCTAssertEqualObjects(gLayer.linePattern, MGLRuntimeStylingHelper.testString); +} + +@end diff --git a/platform/darwin/test/MGLRasterStyleLayerTests.m b/platform/darwin/test/MGLRasterStyleLayerTests.m new file mode 100644 index 0000000000..6d5cd6293b --- /dev/null +++ b/platform/darwin/test/MGLRasterStyleLayerTests.m @@ -0,0 +1,37 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLRasterLayerTests : MGLStyleLayerTests +@end + +@implementation MGLRasterLayerTests + +- (void)testRasterLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLRasterStyleLayer *layer = [[MGLRasterStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.rasterOpacity = MGLRuntimeStylingHelper.testNumber; + layer.rasterHueRotate = MGLRuntimeStylingHelper.testNumber; + layer.rasterBrightnessMin = MGLRuntimeStylingHelper.testNumber; + layer.rasterBrightnessMax = MGLRuntimeStylingHelper.testNumber; + layer.rasterSaturation = MGLRuntimeStylingHelper.testNumber; + layer.rasterContrast = MGLRuntimeStylingHelper.testNumber; + layer.rasterFadeDuration = MGLRuntimeStylingHelper.testNumber; + + MGLRasterStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssertEqualObjects(gLayer.rasterOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterHueRotate, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterBrightnessMin, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterBrightnessMax, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterSaturation, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterContrast, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.rasterFadeDuration, MGLRuntimeStylingHelper.testNumber); +} + +@end diff --git a/platform/darwin/test/MGLRuntimeStylingHelper.h b/platform/darwin/test/MGLRuntimeStylingHelper.h new file mode 100644 index 0000000000..fa1543ec47 --- /dev/null +++ b/platform/darwin/test/MGLRuntimeStylingHelper.h @@ -0,0 +1,25 @@ +#import <Foundation/Foundation.h> + +#import "MGLTypes.h" + +@interface MGLRuntimeStylingHelper : NSObject + ++ (NSArray *)testPadding; + ++ (NSArray *)testOffset; + ++ (NSArray *)testFont; + ++ (NSArray *)testDashArray; + ++ (NSNumber *)testNumber; + ++ (NSNumber *)testBool; + ++ (NSString *)testString; + ++ (MGLColor *)testColor; + ++ (NSValue *)testEnum:(NSUInteger)value type:(const char *)type; + +@end diff --git a/platform/darwin/test/MGLRuntimeStylingHelper.m b/platform/darwin/test/MGLRuntimeStylingHelper.m new file mode 100644 index 0000000000..fbdc8e5225 --- /dev/null +++ b/platform/darwin/test/MGLRuntimeStylingHelper.m @@ -0,0 +1,56 @@ +#import "MGLRuntimeStylingHelper.h" + +#if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR +#import <UIKit/UIKit.h> +#else +#import <Cocoa/Cocoa.h> +#endif + +@implementation MGLRuntimeStylingHelper + ++ (NSArray *)testPadding +{ + return @[@1.0f, @1.0f, @1.0f, @1.0f]; +} + ++ (NSArray *)testOffset +{ + return @[@1.0f, @1.0f]; +} + ++ (NSArray *)testFont +{ + return @[@"Open Sans Regular", @"Arial Unicode MS Regular"]; +} + ++ (NSArray *)testDashArray +{ + return @[@1, @2]; +} + ++ (NSNumber *)testNumber +{ + return @1; +} + ++ (NSNumber *)testBool +{ + return @YES; +} + ++ (NSString *)testString +{ + return @"test"; +} + ++ (MGLColor *)testColor +{ + return [MGLColor redColor]; +} + ++ (NSValue *)testEnum:(NSUInteger)value type:(const char *)type +{ + return [NSValue value:&value withObjCType:type]; +} + +@end diff --git a/platform/darwin/test/MGLStyleLayerTests.h b/platform/darwin/test/MGLStyleLayerTests.h new file mode 100644 index 0000000000..f81e075e03 --- /dev/null +++ b/platform/darwin/test/MGLStyleLayerTests.h @@ -0,0 +1,10 @@ +#import <Mapbox/Mapbox.h> +#import "MGLRuntimeStylingHelper.h" +#import <XCTest/XCTest.h> + +@interface MGLStyleLayerTests : XCTestCase <MGLMapViewDelegate> + +@property (nonatomic) IBOutlet MGLMapView *mapView; +@property (nonatomic) XCTestExpectation *expectation; + +@end diff --git a/platform/darwin/test/MGLStyleLayerTests.m b/platform/darwin/test/MGLStyleLayerTests.m new file mode 100644 index 0000000000..ae0a59edd3 --- /dev/null +++ b/platform/darwin/test/MGLStyleLayerTests.m @@ -0,0 +1,21 @@ +#import "MGLStyleLayerTests.h" + +@implementation MGLStyleLayerTests + +- (void)setUp { + [super setUp]; +#if TARGET_OS_IPHONE + UIApplication *app = [[UIApplication sharedApplication] delegate]; + UIViewController *vc = [[UIViewController alloc] init]; + app.keyWindow.rootViewController = vc; + [vc view]; // Force load xib + _mapView = [[MGLMapView alloc] initWithFrame:CGRectMake(0, 0, 256, 256)]; + [vc.view addSubview:_mapView]; + _mapView.delegate = self; +#else + NSWindowController *windowController = [[NSWindowController alloc] initWithWindowNibName:@"MGLStyleLayerTests" owner:self]; + [windowController showWindow:nil]; +#endif +} + +@end diff --git a/platform/darwin/test/MGLSymbolStyleLayerTests.m b/platform/darwin/test/MGLSymbolStyleLayerTests.m new file mode 100644 index 0000000000..b8c3cdd77b --- /dev/null +++ b/platform/darwin/test/MGLSymbolStyleLayerTests.m @@ -0,0 +1,119 @@ +// This file is generated. +// Edit platform/darwin/scripts/generate-style-code.js, then run `make style-code-darwin`. + +#import "MGLStyleLayerTests.h" + +@interface MGLSymbolLayerTests : MGLStyleLayerTests +@end + +@implementation MGLSymbolLayerTests + +- (void)testSymbolLayer { + NSString *filePath = [[NSBundle bundleForClass:self.class] pathForResource:@"amsterdam" ofType:@"geojson"]; + NSURL *url = [NSURL fileURLWithPath:filePath]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"sourceID" URL:url]; + MGLSymbolStyleLayer *layer = [[MGLSymbolStyleLayer alloc] initWithLayerIdentifier:@"layerID" sourceIdentifier:@"sourceID"]; + [self.mapView.style addSource:source]; + [self.mapView.style addLayer:layer]; + + layer.symbolPlacement = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerSymbolPlacementLine type:@encode(MGLSymbolStyleLayerSymbolPlacement)]; + layer.symbolSpacing = MGLRuntimeStylingHelper.testNumber; + layer.symbolAvoidEdges = MGLRuntimeStylingHelper.testBool; + layer.iconAllowOverlap = MGLRuntimeStylingHelper.testBool; + layer.iconIgnorePlacement = MGLRuntimeStylingHelper.testBool; + layer.iconOptional = MGLRuntimeStylingHelper.testBool; + layer.iconRotationAlignment = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconRotationAlignmentViewport type:@encode(MGLSymbolStyleLayerIconRotationAlignment)]; + layer.iconSize = MGLRuntimeStylingHelper.testNumber; + layer.iconTextFit = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconTextFitHeight type:@encode(MGLSymbolStyleLayerIconTextFit)]; + layer.iconTextFitPadding = MGLRuntimeStylingHelper.testPadding; + layer.iconImage = MGLRuntimeStylingHelper.testString; + layer.iconRotate = MGLRuntimeStylingHelper.testNumber; + layer.iconPadding = MGLRuntimeStylingHelper.testNumber; + layer.iconKeepUpright = MGLRuntimeStylingHelper.testBool; + layer.iconOffset = MGLRuntimeStylingHelper.testOffset; + layer.textPitchAlignment = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextPitchAlignmentViewport type:@encode(MGLSymbolStyleLayerTextPitchAlignment)]; + layer.textRotationAlignment = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextRotationAlignmentViewport type:@encode(MGLSymbolStyleLayerTextRotationAlignment)]; + layer.textField = MGLRuntimeStylingHelper.testString; + layer.textFont = MGLRuntimeStylingHelper.testFont; + layer.textSize = MGLRuntimeStylingHelper.testNumber; + layer.textMaxWidth = MGLRuntimeStylingHelper.testNumber; + layer.textLineHeight = MGLRuntimeStylingHelper.testNumber; + layer.textLetterSpacing = MGLRuntimeStylingHelper.testNumber; + layer.textJustify = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextJustifyRight type:@encode(MGLSymbolStyleLayerTextJustify)]; + layer.textAnchor = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextAnchorBottomRight type:@encode(MGLSymbolStyleLayerTextAnchor)]; + layer.textMaxAngle = MGLRuntimeStylingHelper.testNumber; + layer.textRotate = MGLRuntimeStylingHelper.testNumber; + layer.textPadding = MGLRuntimeStylingHelper.testNumber; + layer.textKeepUpright = MGLRuntimeStylingHelper.testBool; + layer.textTransform = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextTransformLowercase type:@encode(MGLSymbolStyleLayerTextTransform)]; + layer.textOffset = MGLRuntimeStylingHelper.testOffset; + layer.textAllowOverlap = MGLRuntimeStylingHelper.testBool; + layer.textIgnorePlacement = MGLRuntimeStylingHelper.testBool; + layer.textOptional = MGLRuntimeStylingHelper.testBool; + layer.iconOpacity = MGLRuntimeStylingHelper.testNumber; + layer.iconColor = MGLRuntimeStylingHelper.testColor; + layer.iconHaloColor = MGLRuntimeStylingHelper.testColor; + layer.iconHaloWidth = MGLRuntimeStylingHelper.testNumber; + layer.iconHaloBlur = MGLRuntimeStylingHelper.testNumber; + layer.iconTranslate = MGLRuntimeStylingHelper.testOffset; + layer.iconTranslateAnchor = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconTranslateAnchorViewport type:@encode(MGLSymbolStyleLayerIconTranslateAnchor)]; + layer.textOpacity = MGLRuntimeStylingHelper.testNumber; + layer.textColor = MGLRuntimeStylingHelper.testColor; + layer.textHaloColor = MGLRuntimeStylingHelper.testColor; + layer.textHaloWidth = MGLRuntimeStylingHelper.testNumber; + layer.textHaloBlur = MGLRuntimeStylingHelper.testNumber; + layer.textTranslate = MGLRuntimeStylingHelper.testOffset; + layer.textTranslateAnchor = [MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextTranslateAnchorViewport type:@encode(MGLSymbolStyleLayerTextTranslateAnchor)]; + + MGLSymbolStyleLayer *gLayer = [self.mapView.style layerWithIdentifier:@"layerID"]; + XCTAssert([(NSValue *)gLayer.symbolPlacement objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerSymbolPlacementLine type:@encode(MGLSymbolStyleLayerSymbolPlacement)] objCType]); + XCTAssertEqualObjects(gLayer.symbolSpacing, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.symbolAvoidEdges, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.iconAllowOverlap, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.iconIgnorePlacement, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.iconOptional, MGLRuntimeStylingHelper.testBool); + XCTAssert([(NSValue *)gLayer.iconRotationAlignment objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconRotationAlignmentViewport type:@encode(MGLSymbolStyleLayerIconRotationAlignment)] objCType]); + XCTAssertEqualObjects(gLayer.iconSize, MGLRuntimeStylingHelper.testNumber); + XCTAssert([(NSValue *)gLayer.iconTextFit objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconTextFitHeight type:@encode(MGLSymbolStyleLayerIconTextFit)] objCType]); + XCTAssertEqualObjects(gLayer.iconTextFitPadding, MGLRuntimeStylingHelper.testPadding); + XCTAssertEqualObjects(gLayer.iconImage, MGLRuntimeStylingHelper.testString); + XCTAssertEqualObjects(gLayer.iconRotate, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.iconPadding, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.iconKeepUpright, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.iconOffset, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.textPitchAlignment objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextPitchAlignmentViewport type:@encode(MGLSymbolStyleLayerTextPitchAlignment)] objCType]); + XCTAssert([(NSValue *)gLayer.textRotationAlignment objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextRotationAlignmentViewport type:@encode(MGLSymbolStyleLayerTextRotationAlignment)] objCType]); + XCTAssertEqualObjects(gLayer.textField, MGLRuntimeStylingHelper.testString); + XCTAssertEqualObjects(gLayer.textFont, MGLRuntimeStylingHelper.testFont); + XCTAssertEqualObjects(gLayer.textSize, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textMaxWidth, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textLineHeight, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textLetterSpacing, MGLRuntimeStylingHelper.testNumber); + XCTAssert([(NSValue *)gLayer.textJustify objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextJustifyRight type:@encode(MGLSymbolStyleLayerTextJustify)] objCType]); + XCTAssert([(NSValue *)gLayer.textAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextAnchorBottomRight type:@encode(MGLSymbolStyleLayerTextAnchor)] objCType]); + XCTAssertEqualObjects(gLayer.textMaxAngle, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textRotate, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textPadding, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textKeepUpright, MGLRuntimeStylingHelper.testBool); + XCTAssert([(NSValue *)gLayer.textTransform objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextTransformLowercase type:@encode(MGLSymbolStyleLayerTextTransform)] objCType]); + XCTAssertEqualObjects(gLayer.textOffset, MGLRuntimeStylingHelper.testOffset); + XCTAssertEqualObjects(gLayer.textAllowOverlap, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.textIgnorePlacement, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.textOptional, MGLRuntimeStylingHelper.testBool); + XCTAssertEqualObjects(gLayer.iconOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.iconColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.iconHaloColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.iconHaloWidth, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.iconHaloBlur, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.iconTranslate, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.iconTranslateAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerIconTranslateAnchorViewport type:@encode(MGLSymbolStyleLayerIconTranslateAnchor)] objCType]); + XCTAssertEqualObjects(gLayer.textOpacity, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.textHaloColor, MGLRuntimeStylingHelper.testColor); + XCTAssertEqualObjects(gLayer.textHaloWidth, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textHaloBlur, MGLRuntimeStylingHelper.testNumber); + XCTAssertEqualObjects(gLayer.textTranslate, MGLRuntimeStylingHelper.testOffset); + XCTAssert([(NSValue *)gLayer.textTranslateAnchor objCType] == [[MGLRuntimeStylingHelper testEnum:MGLSymbolStyleLayerTextTranslateAnchorViewport type:@encode(MGLSymbolStyleLayerTextTranslateAnchor)] objCType]); +} + +@end diff --git a/platform/ios/app/MBXViewController.m b/platform/ios/app/MBXViewController.m index ef91c847be..df1c446c21 100644 --- a/platform/ios/app/MBXViewController.m +++ b/platform/ios/app/MBXViewController.m @@ -4,6 +4,7 @@ #import "MBXCustomCalloutView.h" #import "MBXOfflinePacksTableViewController.h" #import "MBXAnnotationView.h" +#import "MGLFillStyleLayer.h" #import <Mapbox/Mapbox.h> @@ -200,6 +201,7 @@ static NSString * const MBXViewControllerAnnotationViewReuseIdentifer = @"MBXVie @"Start World Tour", @"Add Custom Callout Point", @"Remove Annotations", + @"Runtime styling", nil]; if (self.debugLoggingEnabled) @@ -277,6 +279,10 @@ static NSString * const MBXViewControllerAnnotationViewReuseIdentifer = @"MBXVie { [self.mapView removeAnnotations:self.mapView.annotations]; } + else if (buttonIndex == actionSheet.firstOtherButtonIndex + 16) + { + [self testRuntimeStyling]; + } else if (buttonIndex == actionSheet.numberOfButtons - 2 && self.debugLoggingEnabled) { NSString *fileContents = [NSString stringWithContentsOfFile:[self telemetryDebugLogfilePath] encoding:NSUTF8StringEncoding error:nil]; @@ -436,6 +442,96 @@ static NSString * const MBXViewControllerAnnotationViewReuseIdentifer = @"MBXVie [self.mapView showAnnotations:@[annotation] animated:YES]; } +- (void)testRuntimeStyling +{ + [self styleWaterLayer]; + [self styleRoadLayer]; + [self styleRasterLayer]; + [self styleGeoJSONSource]; + [self styleSymbolLayer]; + + MGLFillStyleLayer *buildingLayer = (MGLFillStyleLayer *)[self.mapView.style layerWithIdentifier:@"building"]; + buildingLayer.fillColor = [UIColor blackColor]; + + MGLLineStyleLayer *ferryLineLayer = (MGLLineStyleLayer *)[self.mapView.style layerWithIdentifier:@"ferry"]; + ferryLineLayer.lineColor = [UIColor redColor]; + + MGLFillStyleLayer *parkLayer = (MGLFillStyleLayer *)[self.mapView.style layerWithIdentifier:@"park"]; + [self.mapView.style removeLayer:parkLayer]; +} + +- (void)styleSymbolLayer +{ + MGLSymbolStyleLayer *stateLayer = (MGLSymbolStyleLayer *)[self.mapView.style layerWithIdentifier:@"state-label-lg"]; + stateLayer.textColor = [UIColor redColor]; +} + +- (void)styleGeoJSONSource +{ + NSURL *geoJSONURL = [NSURL URLWithString:@"https://dl.dropboxusercontent.com/u/5285447/amsterdam.geojson"]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"ams" URL:geoJSONURL]; + [self.mapView.style addSource:source]; + + MGLFillStyleLayer *fillLayer = [[MGLFillStyleLayer alloc] initWithLayerIdentifier:@"test" sourceIdentifier:@"ams"]; + fillLayer.fillColor = [UIColor purpleColor]; + [self.mapView.style addLayer:fillLayer]; +} + +- (void)styleRasterLayer +{ + NSURL *rasterURL = [NSURL URLWithString:@"mapbox://mapbox.satellite"]; + MGLRasterSource *rasterSource = [[MGLRasterSource alloc] initWithSourceIdentifier:@"my-raster-source" URL:rasterURL tileSize:512]; + [self.mapView.style addSource:rasterSource]; + + MGLRasterStyleLayer *rasterLayer = [[MGLRasterStyleLayer alloc] initWithLayerIdentifier:@"my-raster-layer" sourceIdentifier:@"my-raster-source"]; + MGLStyleAttributeFunction *opacityFunction = [[MGLStyleAttributeFunction alloc] init]; + opacityFunction.stops = @{@20.0f: @1.0f, + @5.0f: @0.0f}; + rasterLayer.rasterOpacity = opacityFunction; + [self.mapView.style addLayer:rasterLayer]; +} + +- (void)styleWaterLayer +{ + MGLFillStyleLayer *waterLayer = (MGLFillStyleLayer *)[self.mapView.style layerWithIdentifier:@"water"]; + MGLStyleAttributeFunction *waterColorFunction = [[MGLStyleAttributeFunction alloc] init]; + waterColorFunction.stops = @{@6.0f: [UIColor yellowColor], + @8.0f: [UIColor blueColor], + @10.0f: [UIColor redColor], + @12.0f: [UIColor greenColor], + @14.0f: [UIColor blueColor]}; + waterLayer.fillColor = waterColorFunction; + + MGLStyleAttributeFunction *fillAntialias = [[MGLStyleAttributeFunction alloc] init]; + fillAntialias.stops = @{@11: @YES, + @12: @NO, + @13: @YES, + @14: @NO, + @15: @YES}; + waterLayer.fillAntialias = fillAntialias; + + [waterLayer update]; +} + +- (void)styleRoadLayer +{ + MGLLineStyleLayer *roadLayer = (MGLLineStyleLayer *)[self.mapView.style layerWithIdentifier:@"road-primary"]; + roadLayer.lineColor = [UIColor blackColor]; + MGLStyleAttributeFunction *lineWidthFunction = [[MGLStyleAttributeFunction alloc] init]; + + MGLStyleAttributeFunction *roadLineColor = [[MGLStyleAttributeFunction alloc] init]; + roadLineColor.stops = @{@10: [UIColor purpleColor], + @13: [UIColor yellowColor], + @16: [UIColor cyanColor]}; + roadLayer.lineColor = roadLineColor; + roadLayer.lineWidth = lineWidthFunction; + roadLayer.lineGapWidth = lineWidthFunction; + + roadLayer.visible = YES; + roadLayer.maximumZoomLevel = 15; + roadLayer.minimumZoomLevel = 13; +} + - (IBAction)handleLongPress:(UILongPressGestureRecognizer *)longPress { if (longPress.state == UIGestureRecognizerStateBegan) diff --git a/platform/ios/config.cmake b/platform/ios/config.cmake index 28bef0cfeb..eb05678f6f 100644 --- a/platform/ios/config.cmake +++ b/platform/ios/config.cmake @@ -39,6 +39,8 @@ macro(mbgl_platform_core) PRIVATE platform/default/headless_view.cpp ) + target_add_mason_package(mbgl-core PUBLIC geojson) + target_compile_options(mbgl-core PRIVATE -fobjc-arc ) @@ -57,4 +59,4 @@ macro(mbgl_platform_core) target_link_libraries(mbgl-core PUBLIC -lz ) -endmacro()
\ No newline at end of file +endmacro() diff --git a/platform/ios/ios.xcodeproj/project.pbxproj b/platform/ios/ios.xcodeproj/project.pbxproj index 1bdc3e7a76..48ae81d136 100644 --- a/platform/ios/ios.xcodeproj/project.pbxproj +++ b/platform/ios/ios.xcodeproj/project.pbxproj @@ -7,12 +7,126 @@ objects = { /* Begin PBXBuildFile section */ + 350098AF1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098AD1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098B01D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098AD1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098B11D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098AE1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm */; }; + 350098B21D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098AE1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm */; }; + 350098BB1D480108004B2AF0 /* MGLVectorSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098B91D480108004B2AF0 /* MGLVectorSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098BC1D480108004B2AF0 /* MGLVectorSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098B91D480108004B2AF0 /* MGLVectorSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098BD1D480108004B2AF0 /* MGLVectorSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 350098BA1D480108004B2AF0 /* MGLVectorSource.m */; }; + 350098BE1D480108004B2AF0 /* MGLVectorSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 350098BA1D480108004B2AF0 /* MGLVectorSource.m */; }; + 350098C11D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098BF1D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098C21D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098BF1D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098C31D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098C01D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm */; }; + 350098C41D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098C01D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm */; }; + 350098C61D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098C51D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098C71D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098C51D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098CA1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098C81D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098CB1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098C81D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098CC1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098C91D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm */; }; + 350098CD1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098C91D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm */; }; + 350098CF1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098CE1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098D01D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098CE1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098D31D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098D11D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098D41D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098D11D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098D51D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098D21D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm */; }; + 350098D61D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098D21D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm */; }; + 350098D81D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098D71D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098D91D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 350098D71D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp */; }; + 350098DC1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098DA1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098DD1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 350098DA1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 350098DE1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098DB1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm */; }; + 350098DF1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 350098DB1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm */; }; + 35136D391D42271A00C20EFD /* MGLBackgroundStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D381D42271A00C20EFD /* MGLBackgroundStyleLayer.mm */; }; + 35136D3A1D42271A00C20EFD /* MGLBackgroundStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D381D42271A00C20EFD /* MGLBackgroundStyleLayer.mm */; }; + 35136D3C1D42272500C20EFD /* MGLCircleStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D3B1D42272500C20EFD /* MGLCircleStyleLayer.mm */; }; + 35136D3D1D42272500C20EFD /* MGLCircleStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D3B1D42272500C20EFD /* MGLCircleStyleLayer.mm */; }; + 35136D3F1D42273000C20EFD /* MGLLineStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D3E1D42273000C20EFD /* MGLLineStyleLayer.mm */; }; + 35136D401D42273000C20EFD /* MGLLineStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D3E1D42273000C20EFD /* MGLLineStyleLayer.mm */; }; + 35136D421D42274500C20EFD /* MGLRasterStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D411D42274500C20EFD /* MGLRasterStyleLayer.mm */; }; + 35136D431D42274500C20EFD /* MGLRasterStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D411D42274500C20EFD /* MGLRasterStyleLayer.mm */; }; + 35136D451D42275100C20EFD /* MGLSymbolStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D441D42275100C20EFD /* MGLSymbolStyleLayer.mm */; }; + 35136D461D42275100C20EFD /* MGLSymbolStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D441D42275100C20EFD /* MGLSymbolStyleLayer.mm */; }; + 35136D4C1D4277FC00C20EFD /* MGLSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 35136D4A1D4277FC00C20EFD /* MGLSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35136D4D1D4277FC00C20EFD /* MGLSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 35136D4A1D4277FC00C20EFD /* MGLSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35136D4E1D4277FC00C20EFD /* MGLSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D4B1D4277FC00C20EFD /* MGLSource.mm */; }; + 35136D4F1D4277FC00C20EFD /* MGLSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35136D4B1D4277FC00C20EFD /* MGLSource.mm */; }; 35305D481D22AA680007D005 /* NSData+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35305D471D22AA450007D005 /* NSData+MGLAdditions.mm */; }; 35305D491D22AA680007D005 /* NSData+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35305D471D22AA450007D005 /* NSData+MGLAdditions.mm */; }; 35305D4A1D22AA6A0007D005 /* NSData+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 35305D461D22AA450007D005 /* NSData+MGLAdditions.h */; settings = {ATTRIBUTES = (Private, ); }; }; + 353349B31D5CC6F20094E9DE /* amsterdam.geojson in Resources */ = {isa = PBXBuildFile; fileRef = 353349B21D5CC6F20094E9DE /* amsterdam.geojson */; }; + 3534C7921D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3534C7911D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp */; }; + 3534C7931D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3534C7911D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp */; }; + 3534C7951D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3534C7941D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp */; }; + 3534C7961D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3534C7941D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp */; }; 353794D01D22B3BD002C281C /* NSData+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 35305D461D22AA450007D005 /* NSData+MGLAdditions.h */; settings = {ATTRIBUTES = (Private, ); }; }; + 3538AA171D541C43008EC33D /* MGLStyleFilter.h in Headers */ = {isa = PBXBuildFile; fileRef = 3538AA151D541C43008EC33D /* MGLStyleFilter.h */; }; + 3538AA181D541C43008EC33D /* MGLStyleFilter.h in Headers */ = {isa = PBXBuildFile; fileRef = 3538AA151D541C43008EC33D /* MGLStyleFilter.h */; }; + 3538AA191D541C43008EC33D /* MGLStyleFilter.m in Sources */ = {isa = PBXBuildFile; fileRef = 3538AA161D541C43008EC33D /* MGLStyleFilter.m */; }; + 3538AA1A1D541C43008EC33D /* MGLStyleFilter.m in Sources */ = {isa = PBXBuildFile; fileRef = 3538AA161D541C43008EC33D /* MGLStyleFilter.m */; }; + 3538AA1D1D542239008EC33D /* MGLBaseStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 3538AA1B1D542239008EC33D /* MGLBaseStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3538AA1E1D542239008EC33D /* MGLBaseStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 3538AA1B1D542239008EC33D /* MGLBaseStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3538AA1F1D542239008EC33D /* MGLBaseStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3538AA1C1D542239008EC33D /* MGLBaseStyleLayer.mm */; }; + 3538AA201D542239008EC33D /* MGLBaseStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3538AA1C1D542239008EC33D /* MGLBaseStyleLayer.mm */; }; + 353933F21D3FB753003F57D7 /* MGLCircleStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F11D3FB753003F57D7 /* MGLCircleStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933F31D3FB753003F57D7 /* MGLCircleStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F11D3FB753003F57D7 /* MGLCircleStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933F51D3FB785003F57D7 /* MGLBackgroundStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F41D3FB785003F57D7 /* MGLBackgroundStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933F61D3FB785003F57D7 /* MGLBackgroundStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F41D3FB785003F57D7 /* MGLBackgroundStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933F81D3FB79F003F57D7 /* MGLLineStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F71D3FB79F003F57D7 /* MGLLineStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933F91D3FB79F003F57D7 /* MGLLineStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933F71D3FB79F003F57D7 /* MGLLineStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933FB1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933FA1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933FC1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933FA1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933FE1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933FD1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 353933FF1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 353933FD1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; 353D23961D0B0DFE002BE09D /* MGLAnnotationViewTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 353D23951D0B0DFE002BE09D /* MGLAnnotationViewTests.m */; }; + 354D42DC1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 354D42DB1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */; }; + 354D42DD1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 354D42DB1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */; }; + 35599DEB1D46F14E0048254D /* MGLStyleAttributeFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 35599DE91D46F14E0048254D /* MGLStyleAttributeFunction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35599DEC1D46F14E0048254D /* MGLStyleAttributeFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 35599DE91D46F14E0048254D /* MGLStyleAttributeFunction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35599DED1D46F14E0048254D /* MGLStyleAttributeFunction.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35599DEA1D46F14E0048254D /* MGLStyleAttributeFunction.mm */; }; + 35599DEE1D46F14E0048254D /* MGLStyleAttributeFunction.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35599DEA1D46F14E0048254D /* MGLStyleAttributeFunction.mm */; }; + 35599DF01D46F3A60048254D /* MGLStyleAttributeValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 35599DEF1D46F3A60048254D /* MGLStyleAttributeValue.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35599DF11D46F3A60048254D /* MGLStyleAttributeValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 35599DEF1D46F3A60048254D /* MGLStyleAttributeValue.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3566C7661D4A77BA008152BC /* MGLGeoJSONSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7641D4A77BA008152BC /* MGLGeoJSONSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3566C7671D4A77BA008152BC /* MGLGeoJSONSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7641D4A77BA008152BC /* MGLGeoJSONSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3566C7681D4A77BA008152BC /* MGLGeoJSONSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3566C7651D4A77BA008152BC /* MGLGeoJSONSource.mm */; }; + 3566C7691D4A77BA008152BC /* MGLGeoJSONSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3566C7651D4A77BA008152BC /* MGLGeoJSONSource.mm */; }; + 3566C76C1D4A8DFA008152BC /* MGLRasterSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C76A1D4A8DFA008152BC /* MGLRasterSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3566C76D1D4A8DFA008152BC /* MGLRasterSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 3566C76A1D4A8DFA008152BC /* MGLRasterSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3566C76E1D4A8DFA008152BC /* MGLRasterSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */; }; + 3566C76F1D4A8DFA008152BC /* MGLRasterSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */; }; + 3566C7711D4A9198008152BC /* MGLSource_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7701D4A9198008152BC /* MGLSource_Private.hpp */; }; + 3566C7721D4A9198008152BC /* MGLSource_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3566C7701D4A9198008152BC /* MGLSource_Private.hpp */; }; + 357579801D501E09000B822E /* MGLFillStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */; }; + 357579831D502AE6000B822E /* MGLRasterStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */; }; + 357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */; }; + 357579871D502AFE000B822E /* MGLLineStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */; }; + 357579891D502B06000B822E /* MGLCircleStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */; }; + 3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */; }; + 3575798E1D502EC7000B822E /* MGLRuntimeStylingHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = 3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */; }; + 3593E5211D529C29006D9365 /* MGLStyleAttribute.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E51F1D529C29006D9365 /* MGLStyleAttribute.hpp */; }; + 3593E5221D529C29006D9365 /* MGLStyleAttribute.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E51F1D529C29006D9365 /* MGLStyleAttribute.hpp */; }; + 3593E5231D529C29006D9365 /* MGLStyleAttribute.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3593E5201D529C29006D9365 /* MGLStyleAttribute.mm */; }; + 3593E5241D529C29006D9365 /* MGLStyleAttribute.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3593E5201D529C29006D9365 /* MGLStyleAttribute.mm */; }; + 3593E5261D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E5251D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp */; }; + 3593E5271D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E5251D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp */; }; + 35CE61821D4165D9004F2359 /* UIColor+MGLAdditions.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35CE61801D4165D9004F2359 /* UIColor+MGLAdditions.hpp */; }; + 35CE61831D4165D9004F2359 /* UIColor+MGLAdditions.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35CE61801D4165D9004F2359 /* UIColor+MGLAdditions.hpp */; }; + 35CE61841D4165D9004F2359 /* UIColor+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35CE61811D4165D9004F2359 /* UIColor+MGLAdditions.mm */; }; + 35CE61851D4165D9004F2359 /* UIColor+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35CE61811D4165D9004F2359 /* UIColor+MGLAdditions.mm */; }; + 35D13AB71D3D15E300AFB4E0 /* MGLStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35D13AB51D3D15E300AFB4E0 /* MGLStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35D13AB81D3D15E300AFB4E0 /* MGLStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35D13AB51D3D15E300AFB4E0 /* MGLStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35D13AB91D3D15E300AFB4E0 /* MGLStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35D13AB61D3D15E300AFB4E0 /* MGLStyleLayer.mm */; }; + 35D13ABA1D3D15E300AFB4E0 /* MGLStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35D13AB61D3D15E300AFB4E0 /* MGLStyleLayer.mm */; }; + 35D13AC31D3D19DD00AFB4E0 /* MGLFillStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35D13AC11D3D19DD00AFB4E0 /* MGLFillStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35D13AC41D3D19DD00AFB4E0 /* MGLFillStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35D13AC11D3D19DD00AFB4E0 /* MGLFillStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35D13AC51D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35D13AC21D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm */; }; + 35D13AC61D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35D13AC21D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm */; }; + 35E0CFE61D3E501500188327 /* MGLStyle_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35E0CFE51D3E501500188327 /* MGLStyle_Private.hpp */; }; + 35E0CFE71D3E501500188327 /* MGLStyle_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35E0CFE51D3E501500188327 /* MGLStyle_Private.hpp */; }; 35E208A71D24210F00EC9A46 /* MGLNSDataAdditionsTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 35E208A61D24210F00EC9A46 /* MGLNSDataAdditionsTests.m */; }; + 35E79F201D41266300957B9E /* MGLStyleLayer_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35E79F1F1D41266300957B9E /* MGLStyleLayer_Private.hpp */; }; + 35E79F211D41266300957B9E /* MGLStyleLayer_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35E79F1F1D41266300957B9E /* MGLStyleLayer_Private.hpp */; }; 36F1153D1D46080700878E1A /* libmbgl-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 36F1153B1D46080700878E1A /* libmbgl-core.a */; }; 4018B1C71CDC287F00F666AF /* MGLAnnotationView.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4018B1C41CDC277F00F666AF /* MGLAnnotationView.mm */; }; 4018B1C81CDC287F00F666AF /* MGLAnnotationView.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4018B1C41CDC277F00F666AF /* MGLAnnotationView.mm */; }; @@ -27,8 +141,8 @@ 554180421D2E97DE00012372 /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 554180411D2E97DE00012372 /* OpenGLES.framework */; }; 55D8C9961D0F18CE00F42F10 /* libsqlite3.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 55D8C9951D0F18CE00F42F10 /* libsqlite3.tbd */; }; DA0CD5901CF56F6A00A5F5A5 /* MGLFeatureTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA0CD58F1CF56F6A00A5F5A5 /* MGLFeatureTests.mm */; }; - DA17BE301CC4BAC300402C41 /* MGLMapView_Internal.h in Headers */ = {isa = PBXBuildFile; fileRef = DA17BE2F1CC4BAC300402C41 /* MGLMapView_Internal.h */; }; - DA17BE311CC4BDAA00402C41 /* MGLMapView_Internal.h in Headers */ = {isa = PBXBuildFile; fileRef = DA17BE2F1CC4BAC300402C41 /* MGLMapView_Internal.h */; }; + DA17BE301CC4BAC300402C41 /* MGLMapView_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA17BE2F1CC4BAC300402C41 /* MGLMapView_Private.hpp */; }; + DA17BE311CC4BDAA00402C41 /* MGLMapView_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA17BE2F1CC4BAC300402C41 /* MGLMapView_Private.hpp */; }; DA1DC96A1CB6C6B7006E619F /* MBXCustomCalloutView.m in Sources */ = {isa = PBXBuildFile; fileRef = DA1DC9671CB6C6B7006E619F /* MBXCustomCalloutView.m */; }; DA1DC96B1CB6C6B7006E619F /* MBXOfflinePacksTableViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = DA1DC9691CB6C6B7006E619F /* MBXOfflinePacksTableViewController.m */; }; DA1DC9701CB6C6CE006E619F /* points.geojson in Resources */ = {isa = PBXBuildFile; fileRef = DA1DC96C1CB6C6CE006E619F /* points.geojson */; }; @@ -44,6 +158,7 @@ DA25D5CD1CCDA11500607828 /* Settings.bundle in Resources */ = {isa = PBXBuildFile; fileRef = DA25D5B91CCD9EDE00607828 /* Settings.bundle */; }; DA27C24E1CBB3811000B0ECD /* GLKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = DA27C24D1CBB3811000B0ECD /* GLKit.framework */; }; DA27C24F1CBB4C11000B0ECD /* MGLAccountManager_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8847FF1CBAFA6200AB86E3 /* MGLAccountManager_Private.h */; }; + DA2DBBCE1D51E80400D38FF9 /* MGLStyleLayerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA2DBBCD1D51E80400D38FF9 /* MGLStyleLayerTests.m */; }; DA2E88561CC036F400F24E7B /* Mapbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = DA8847D21CBAF91600AB86E3 /* Mapbox.framework */; }; DA2E88611CC0382C00F24E7B /* MGLGeometryTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA2E885C1CC0382C00F24E7B /* MGLGeometryTests.mm */; }; DA2E88621CC0382C00F24E7B /* MGLOfflinePackTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA2E885D1CC0382C00F24E7B /* MGLOfflinePackTests.m */; }; @@ -332,10 +447,73 @@ /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ + 350098AD1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "UIColor+MGLStyleAttributeAdditions.h"; path = "src/UIColor+MGLStyleAttributeAdditions.h"; sourceTree = SOURCE_ROOT; }; + 350098AE1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = "UIColor+MGLStyleAttributeAdditions.mm"; path = "src/UIColor+MGLStyleAttributeAdditions.mm"; sourceTree = SOURCE_ROOT; }; + 350098B91D480108004B2AF0 /* MGLVectorSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLVectorSource.h; sourceTree = "<group>"; }; + 350098BA1D480108004B2AF0 /* MGLVectorSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLVectorSource.m; sourceTree = "<group>"; }; + 350098BF1D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSNumber+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + 350098C01D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSNumber+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + 350098C51D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSNumber+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + 350098C81D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSArray+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + 350098C91D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSArray+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + 350098CE1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSArray+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + 350098D11D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + 350098D21D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSString+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + 350098D71D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSString+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + 350098DA1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSValue+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + 350098DB1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSValue+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + 35136D381D42271A00C20EFD /* MGLBackgroundStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBackgroundStyleLayer.mm; sourceTree = "<group>"; }; + 35136D3B1D42272500C20EFD /* MGLCircleStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLCircleStyleLayer.mm; sourceTree = "<group>"; }; + 35136D3E1D42273000C20EFD /* MGLLineStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLLineStyleLayer.mm; sourceTree = "<group>"; }; + 35136D411D42274500C20EFD /* MGLRasterStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterStyleLayer.mm; sourceTree = "<group>"; }; + 35136D441D42275100C20EFD /* MGLSymbolStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLSymbolStyleLayer.mm; sourceTree = "<group>"; }; + 35136D4A1D4277FC00C20EFD /* MGLSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLSource.h; sourceTree = "<group>"; }; + 35136D4B1D4277FC00C20EFD /* MGLSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLSource.mm; sourceTree = "<group>"; }; 35305D461D22AA450007D005 /* NSData+MGLAdditions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "NSData+MGLAdditions.h"; sourceTree = "<group>"; }; 35305D471D22AA450007D005 /* NSData+MGLAdditions.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSData+MGLAdditions.mm"; sourceTree = "<group>"; }; + 353349B21D5CC6F20094E9DE /* amsterdam.geojson */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = amsterdam.geojson; sourceTree = "<group>"; }; + 3534C7911D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttributeFunction_Private.hpp; sourceTree = "<group>"; }; + 3534C7941D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttributeValue_Private.hpp; sourceTree = "<group>"; }; + 3538AA151D541C43008EC33D /* MGLStyleFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleFilter.h; sourceTree = "<group>"; }; + 3538AA161D541C43008EC33D /* MGLStyleFilter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLStyleFilter.m; sourceTree = "<group>"; }; + 3538AA1B1D542239008EC33D /* MGLBaseStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLBaseStyleLayer.h; sourceTree = "<group>"; }; + 3538AA1C1D542239008EC33D /* MGLBaseStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBaseStyleLayer.mm; sourceTree = "<group>"; }; + 353933F11D3FB753003F57D7 /* MGLCircleStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLCircleStyleLayer.h; sourceTree = "<group>"; }; + 353933F41D3FB785003F57D7 /* MGLBackgroundStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLBackgroundStyleLayer.h; sourceTree = "<group>"; }; + 353933F71D3FB79F003F57D7 /* MGLLineStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLLineStyleLayer.h; sourceTree = "<group>"; }; + 353933FA1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLRasterStyleLayer.h; sourceTree = "<group>"; }; + 353933FD1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLSymbolStyleLayer.h; sourceTree = "<group>"; }; 353D23951D0B0DFE002BE09D /* MGLAnnotationViewTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLAnnotationViewTests.m; sourceTree = "<group>"; }; + 354D42DB1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSValue+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + 35599DE91D46F14E0048254D /* MGLStyleAttributeFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleAttributeFunction.h; sourceTree = "<group>"; }; + 35599DEA1D46F14E0048254D /* MGLStyleAttributeFunction.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleAttributeFunction.mm; sourceTree = "<group>"; }; + 35599DEF1D46F3A60048254D /* MGLStyleAttributeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleAttributeValue.h; sourceTree = "<group>"; }; + 3566C7641D4A77BA008152BC /* MGLGeoJSONSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLGeoJSONSource.h; sourceTree = "<group>"; }; + 3566C7651D4A77BA008152BC /* MGLGeoJSONSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLGeoJSONSource.mm; sourceTree = "<group>"; }; + 3566C76A1D4A8DFA008152BC /* MGLRasterSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLRasterSource.h; sourceTree = "<group>"; }; + 3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterSource.mm; sourceTree = "<group>"; }; + 3566C7701D4A9198008152BC /* MGLSource_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLSource_Private.hpp; sourceTree = "<group>"; }; + 3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLFillStyleLayerTests.m; path = ../../darwin/test/MGLFillStyleLayerTests.m; sourceTree = "<group>"; }; + 357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRasterStyleLayerTests.m; path = ../../darwin/test/MGLRasterStyleLayerTests.m; sourceTree = "<group>"; }; + 357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLSymbolStyleLayerTests.m; path = ../../darwin/test/MGLSymbolStyleLayerTests.m; sourceTree = "<group>"; }; + 357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLLineStyleLayerTests.m; path = ../../darwin/test/MGLLineStyleLayerTests.m; sourceTree = "<group>"; }; + 357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCircleStyleLayerTests.m; path = ../../darwin/test/MGLCircleStyleLayerTests.m; sourceTree = "<group>"; }; + 3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLBackgroundStyleLayerTests.m; path = ../../darwin/test/MGLBackgroundStyleLayerTests.m; sourceTree = "<group>"; }; + 3575798C1D502EC7000B822E /* MGLRuntimeStylingHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLRuntimeStylingHelper.h; path = ../../darwin/test/MGLRuntimeStylingHelper.h; sourceTree = "<group>"; }; + 3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRuntimeStylingHelper.m; path = ../../darwin/test/MGLRuntimeStylingHelper.m; sourceTree = "<group>"; }; + 3593E51F1D529C29006D9365 /* MGLStyleAttribute.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttribute.hpp; sourceTree = "<group>"; }; + 3593E5201D529C29006D9365 /* MGLStyleAttribute.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleAttribute.mm; sourceTree = "<group>"; }; + 3593E5251D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "UIColor+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + 35CE61801D4165D9004F2359 /* UIColor+MGLAdditions.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "UIColor+MGLAdditions.hpp"; sourceTree = "<group>"; }; + 35CE61811D4165D9004F2359 /* UIColor+MGLAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "UIColor+MGLAdditions.mm"; sourceTree = "<group>"; }; + 35D13AB51D3D15E300AFB4E0 /* MGLStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleLayer.h; sourceTree = "<group>"; }; + 35D13AB61D3D15E300AFB4E0 /* MGLStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleLayer.mm; sourceTree = "<group>"; }; + 35D13AC11D3D19DD00AFB4E0 /* MGLFillStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLFillStyleLayer.h; sourceTree = "<group>"; }; + 35D13AC21D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLFillStyleLayer.mm; sourceTree = "<group>"; }; + 35E0CFE51D3E501500188327 /* MGLStyle_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyle_Private.hpp; sourceTree = "<group>"; }; + 35E0CFE81D3E53FE00188327 /* MGLStyle_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyle_Private.hpp; sourceTree = "<group>"; }; 35E208A61D24210F00EC9A46 /* MGLNSDataAdditionsTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLNSDataAdditionsTests.m; sourceTree = "<group>"; }; + 35E79F1F1D41266300957B9E /* MGLStyleLayer_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleLayer_Private.hpp; sourceTree = "<group>"; }; 36F1153B1D46080700878E1A /* libmbgl-core.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libmbgl-core.a"; path = "build/Debug-iphoneos/libmbgl-core.a"; sourceTree = "<group>"; }; 36F1153C1D46080700878E1A /* libmbgl-platform-ios.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libmbgl-platform-ios.a"; path = "build/Debug-iphoneos/libmbgl-platform-ios.a"; sourceTree = "<group>"; }; 4018B1C31CDC277F00F666AF /* MGLAnnotationView_Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLAnnotationView_Private.h; sourceTree = "<group>"; }; @@ -351,7 +529,7 @@ 55D8C9941D0F133500F42F10 /* config.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = config.xcconfig; path = ../../build/ios/config.xcconfig; sourceTree = "<group>"; }; 55D8C9951D0F18CE00F42F10 /* libsqlite3.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libsqlite3.tbd; path = usr/lib/libsqlite3.tbd; sourceTree = SDKROOT; }; DA0CD58F1CF56F6A00A5F5A5 /* MGLFeatureTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLFeatureTests.mm; path = ../../darwin/test/MGLFeatureTests.mm; sourceTree = "<group>"; }; - DA17BE2F1CC4BAC300402C41 /* MGLMapView_Internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLMapView_Internal.h; sourceTree = "<group>"; }; + DA17BE2F1CC4BAC300402C41 /* MGLMapView_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLMapView_Private.hpp; sourceTree = "<group>"; }; DA1DC94A1CB6C1C2006E619F /* Mapbox GL.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "Mapbox GL.app"; sourceTree = BUILT_PRODUCTS_DIR; }; DA1DC9501CB6C1C2006E619F /* MBXAppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MBXAppDelegate.h; sourceTree = "<group>"; }; DA1DC9531CB6C1C2006E619F /* MBXViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MBXViewController.h; sourceTree = "<group>"; }; @@ -372,6 +550,8 @@ DA25D5BF1CCD9F8400607828 /* Root.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Root.plist; sourceTree = "<group>"; }; DA25D5C51CCDA06800607828 /* Base */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = Base; path = Base.lproj/Root.strings; sourceTree = "<group>"; }; DA27C24D1CBB3811000B0ECD /* GLKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GLKit.framework; path = System/Library/Frameworks/GLKit.framework; sourceTree = SDKROOT; }; + DA2DBBCC1D51E80400D38FF9 /* MGLStyleLayerTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLStyleLayerTests.h; path = ../../darwin/test/MGLStyleLayerTests.h; sourceTree = "<group>"; }; + DA2DBBCD1D51E80400D38FF9 /* MGLStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLStyleLayerTests.m; path = ../../darwin/test/MGLStyleLayerTests.m; sourceTree = "<group>"; }; DA2E88511CC036F400F24E7B /* test.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = test.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; DA2E88551CC036F400F24E7B /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; }; DA2E885C1CC0382C00F24E7B /* MGLGeometryTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLGeometryTests.mm; path = ../../darwin/test/MGLGeometryTests.mm; sourceTree = "<group>"; }; @@ -491,6 +671,9 @@ DA8963341CC549A100684375 /* sprites */ = {isa = PBXFileReference; lastKnownFileType = folder; path = sprites; sourceTree = "<group>"; }; DA8963351CC549A100684375 /* styles */ = {isa = PBXFileReference; lastKnownFileType = folder; path = styles; sourceTree = "<group>"; }; DA8963361CC549A100684375 /* tiles */ = {isa = PBXFileReference; lastKnownFileType = folder; path = tiles; sourceTree = "<group>"; }; + DA8F25B91D51D2570010E6B5 /* MGLRuntimeStylingTests.m.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLRuntimeStylingTests.m.ejs; sourceTree = "<group>"; }; + DA8F25BA1D51D2570010E6B5 /* MGLStyleLayer.h.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.h.ejs; sourceTree = "<group>"; }; + DA8F25BB1D51D2570010E6B5 /* MGLStyleLayer.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.mm.ejs; sourceTree = "<group>"; }; DAA4E4021CBB5C2F00178DFB /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; }; DAA4E4041CBB5C9E00178DFB /* ImageIO.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = ImageIO.framework; path = System/Library/Frameworks/ImageIO.framework; sourceTree = SDKROOT; }; DAA4E4061CBB5CBF00178DFB /* MobileCoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = MobileCoreServices.framework; path = System/Library/Frameworks/MobileCoreServices.framework; sourceTree = SDKROOT; }; @@ -564,6 +747,122 @@ /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ + 35136D491D4277EA00C20EFD /* Sources */ = { + isa = PBXGroup; + children = ( + 35136D4A1D4277FC00C20EFD /* MGLSource.h */, + 3566C7701D4A9198008152BC /* MGLSource_Private.hpp */, + 35136D4B1D4277FC00C20EFD /* MGLSource.mm */, + 350098B91D480108004B2AF0 /* MGLVectorSource.h */, + 350098BA1D480108004B2AF0 /* MGLVectorSource.m */, + 3566C7641D4A77BA008152BC /* MGLGeoJSONSource.h */, + 3566C7651D4A77BA008152BC /* MGLGeoJSONSource.mm */, + 3566C76A1D4A8DFA008152BC /* MGLRasterSource.h */, + 3566C76B1D4A8DFA008152BC /* MGLRasterSource.mm */, + ); + name = Sources; + sourceTree = "<group>"; + }; + 353933F01D3FB6BA003F57D7 /* Layers */ = { + isa = PBXGroup; + children = ( + 353933F41D3FB785003F57D7 /* MGLBackgroundStyleLayer.h */, + 35136D381D42271A00C20EFD /* MGLBackgroundStyleLayer.mm */, + 353933F11D3FB753003F57D7 /* MGLCircleStyleLayer.h */, + 35136D3B1D42272500C20EFD /* MGLCircleStyleLayer.mm */, + 35D13AC11D3D19DD00AFB4E0 /* MGLFillStyleLayer.h */, + 35D13AC21D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm */, + 353933F71D3FB79F003F57D7 /* MGLLineStyleLayer.h */, + 35136D3E1D42273000C20EFD /* MGLLineStyleLayer.mm */, + 353933FA1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h */, + 35136D411D42274500C20EFD /* MGLRasterStyleLayer.mm */, + 35D13AB51D3D15E300AFB4E0 /* MGLStyleLayer.h */, + 35E79F1F1D41266300957B9E /* MGLStyleLayer_Private.hpp */, + 35D13AB61D3D15E300AFB4E0 /* MGLStyleLayer.mm */, + 353933FD1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h */, + 35136D441D42275100C20EFD /* MGLSymbolStyleLayer.mm */, + 3538AA1B1D542239008EC33D /* MGLBaseStyleLayer.h */, + 3538AA1C1D542239008EC33D /* MGLBaseStyleLayer.mm */, + ); + name = Layers; + sourceTree = "<group>"; + }; + 35599DA21D4682B60048254D /* Styling */ = { + isa = PBXGroup; + children = ( + 35599DB81D46AD7F0048254D /* Categories */, + 353933F01D3FB6BA003F57D7 /* Layers */, + 35136D491D4277EA00C20EFD /* Sources */, + 35599DE91D46F14E0048254D /* MGLStyleAttributeFunction.h */, + 3534C7911D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp */, + 35599DEA1D46F14E0048254D /* MGLStyleAttributeFunction.mm */, + 35599DEF1D46F3A60048254D /* MGLStyleAttributeValue.h */, + 3534C7941D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp */, + 3593E51F1D529C29006D9365 /* MGLStyleAttribute.hpp */, + 3593E5201D529C29006D9365 /* MGLStyleAttribute.mm */, + 3538AA151D541C43008EC33D /* MGLStyleFilter.h */, + 3538AA161D541C43008EC33D /* MGLStyleFilter.m */, + ); + name = Styling; + sourceTree = "<group>"; + }; + 35599DB81D46AD7F0048254D /* Categories */ = { + isa = PBXGroup; + children = ( + 350098AD1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h */, + 3593E5251D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp */, + 350098AE1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm */, + 350098BF1D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h */, + 350098C51D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */, + 350098C01D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm */, + 350098C81D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h */, + 350098CE1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */, + 350098C91D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm */, + 350098D11D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h */, + 350098D71D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp */, + 350098D21D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm */, + 350098DA1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h */, + 354D42DB1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */, + 350098DB1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm */, + ); + name = Categories; + sourceTree = "<group>"; + }; + 357579811D502AD4000B822E /* Styling */ = { + isa = PBXGroup; + children = ( + 353349B21D5CC6F20094E9DE /* amsterdam.geojson */, + 3575798F1D513EF1000B822E /* Layers */, + ); + name = Styling; + sourceTree = "<group>"; + }; + 3575798F1D513EF1000B822E /* Layers */ = { + isa = PBXGroup; + children = ( + DA2DBBCC1D51E80400D38FF9 /* MGLStyleLayerTests.h */, + DA2DBBCD1D51E80400D38FF9 /* MGLStyleLayerTests.m */, + 3575797F1D501E09000B822E /* MGLFillStyleLayerTests.m */, + 357579821D502AE6000B822E /* MGLRasterStyleLayerTests.m */, + 357579841D502AF5000B822E /* MGLSymbolStyleLayerTests.m */, + 357579861D502AFE000B822E /* MGLLineStyleLayerTests.m */, + 357579881D502B06000B822E /* MGLCircleStyleLayerTests.m */, + 3575798A1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m */, + 3575798C1D502EC7000B822E /* MGLRuntimeStylingHelper.h */, + 3575798D1D502EC7000B822E /* MGLRuntimeStylingHelper.m */, + ); + name = Layers; + sourceTree = "<group>"; + }; + 35CE617F1D4165C2004F2359 /* Categories */ = { + isa = PBXGroup; + children = ( + 35CE61801D4165D9004F2359 /* UIColor+MGLAdditions.hpp */, + 35CE61811D4165D9004F2359 /* UIColor+MGLAdditions.mm */, + ); + name = Categories; + sourceTree = "<group>"; + }; 402E9DE21CD3A56500FD4519 /* Playground */ = { isa = PBXGroup; children = ( @@ -665,7 +964,7 @@ DA2E88521CC036F400F24E7B /* SDK Tests */ = { isa = PBXGroup; children = ( - DA2E88551CC036F400F24E7B /* Info.plist */, + 357579811D502AD4000B822E /* Styling */, 353D23951D0B0DFE002BE09D /* MGLAnnotationViewTests.m */, DA35A2C31CCA9F8300E826B2 /* MGLClockDirectionFormatterTests.m */, DA35A2C41CCA9F8300E826B2 /* MGLCompassDirectionFormatterTests.m */, @@ -677,6 +976,7 @@ DA2E885E1CC0382C00F24E7B /* MGLOfflineRegionTests.m */, DA2E885F1CC0382C00F24E7B /* MGLOfflineStorageTests.m */, DA2E88601CC0382C00F24E7B /* MGLStyleTests.mm */, + DA2E88551CC036F400F24E7B /* Info.plist */, ); name = "SDK Tests"; path = test; @@ -687,6 +987,7 @@ children = ( DA88485E1CBAFC2E00AB86E3 /* Mapbox.h */, DA8847DE1CBAFA3E00AB86E3 /* Foundation */, + DA8F25BC1D51D2570010E6B5 /* Foundation Templates */, DA8933B91CCD2C6700E68420 /* Foundation Resources */, DA8848331CBAFB2A00AB86E3 /* Kit */, DA8848621CBAFCC100AB86E3 /* Kit Resources */, @@ -701,6 +1002,7 @@ DA8847DE1CBAFA3E00AB86E3 /* Foundation */ = { isa = PBXGroup; children = ( + 35599DA21D4682B60048254D /* Styling */, DAD165831CF4CFED001FF4B9 /* Categories */, DAD165801CF4CF9A001FF4B9 /* Formatters */, DAD165811CF4CFC4001FF4B9 /* Geometry */, @@ -711,10 +1013,12 @@ DA8847E21CBAFA5100AB86E3 /* MGLMapCamera.h */, DA8848031CBAFA6200AB86E3 /* MGLMapCamera.mm */, DA8847EC1CBAFA5100AB86E3 /* MGLStyle.h */, + 35E0CFE51D3E501500188327 /* MGLStyle_Private.hpp */, DA88480F1CBAFA6200AB86E3 /* MGLStyle.mm */, DA8847EE1CBAFA5100AB86E3 /* MGLTypes.h */, DA8848111CBAFA6200AB86E3 /* MGLTypes.m */, DA8848911CBB049300AB86E3 /* reachability */, + 35E0CFE81D3E53FE00188327 /* MGLStyle_Private.hpp */, ); name = Foundation; path = ../darwin/src; @@ -723,10 +1027,11 @@ DA8848331CBAFB2A00AB86E3 /* Kit */ = { isa = PBXGroup; children = ( + 35CE617F1D4165C2004F2359 /* Categories */, DAD165841CF4D06B001FF4B9 /* Annotations */, DAD165851CF4D08B001FF4B9 /* Telemetry */, DA8848361CBAFB8500AB86E3 /* MGLMapView.h */, - DA17BE2F1CC4BAC300402C41 /* MGLMapView_Internal.h */, + DA17BE2F1CC4BAC300402C41 /* MGLMapView_Private.hpp */, DA8848371CBAFB8500AB86E3 /* MGLMapView+IBAdditions.h */, DA8848381CBAFB8500AB86E3 /* MGLMapView+MGLCustomStyleLayerAdditions.h */, DA737EE01D056A4E005BDA16 /* MGLMapViewDelegate.h */, @@ -815,6 +1120,17 @@ path = assets; sourceTree = "<group>"; }; + DA8F25BC1D51D2570010E6B5 /* Foundation Templates */ = { + isa = PBXGroup; + children = ( + DA8F25B91D51D2570010E6B5 /* MGLRuntimeStylingTests.m.ejs */, + DA8F25BA1D51D2570010E6B5 /* MGLStyleLayer.h.ejs */, + DA8F25BB1D51D2570010E6B5 /* MGLStyleLayer.mm.ejs */, + ); + name = "Foundation Templates"; + path = ../../darwin/src; + sourceTree = "<group>"; + }; DABCABA91CB80692000A7C39 /* Benchmarking App */ = { isa = PBXGroup; children = ( @@ -971,63 +1287,95 @@ isa = PBXHeadersBuildPhase; buildActionMask = 2147483647; files = ( + 35D13AC31D3D19DD00AFB4E0 /* MGLFillStyleLayer.h in Headers */, DA88483A1CBAFB8500AB86E3 /* MGLAnnotationImage.h in Headers */, DA35A2BB1CCA9A6900E826B2 /* MGLClockDirectionFormatter.h in Headers */, + 353933FE1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h in Headers */, DA8848861CBB033F00AB86E3 /* Fabric+FABKits.h in Headers */, DA8848201CBAFA6200AB86E3 /* MGLOfflinePack_Private.h in Headers */, DA8847FA1CBAFA5100AB86E3 /* MGLPolyline.h in Headers */, + 3566C7711D4A9198008152BC /* MGLSource_Private.hpp in Headers */, + 3593E5211D529C29006D9365 /* MGLStyleAttribute.hpp in Headers */, + 35599DEB1D46F14E0048254D /* MGLStyleAttributeFunction.h in Headers */, 4018B1C91CDC288A00F666AF /* MGLAnnotationView_Private.h in Headers */, DA88482C1CBAFA6200AB86E3 /* NSBundle+MGLAdditions.h in Headers */, + 35D13AB71D3D15E300AFB4E0 /* MGLStyleLayer.h in Headers */, + 354D42DC1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */, DA88488E1CBB047F00AB86E3 /* reachability.h in Headers */, + 350098DC1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h in Headers */, DA8848231CBAFA6200AB86E3 /* MGLOfflineStorage_Private.h in Headers */, 404326891D5B9B27007111BD /* MGLAnnotationContainerView_Private.h in Headers */, DA88483B1CBAFB8500AB86E3 /* MGLCalloutView.h in Headers */, + 35E0CFE61D3E501500188327 /* MGLStyle_Private.hpp in Headers */, + 3593E5261D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 35599DF01D46F3A60048254D /* MGLStyleAttributeValue.h in Headers */, DA8848531CBAFB9800AB86E3 /* MGLCompactCalloutView.h in Headers */, DA8847FB1CBAFA5100AB86E3 /* MGLShape.h in Headers */, + 353933F51D3FB785003F57D7 /* MGLBackgroundStyleLayer.h in Headers */, DA88485A1CBAFB9800AB86E3 /* MGLUserLocation_Private.h in Headers */, DA27C24F1CBB4C11000B0ECD /* MGLAccountManager_Private.h in Headers */, DA8847FC1CBAFA5100AB86E3 /* MGLStyle.h in Headers */, DA8847F01CBAFA5100AB86E3 /* MGLAnnotation.h in Headers */, DA88483E1CBAFB8500AB86E3 /* MGLMapView+MGLCustomStyleLayerAdditions.h in Headers */, 4018B1CA1CDC288E00F666AF /* MGLAnnotationView.h in Headers */, + 35E79F201D41266300957B9E /* MGLStyleLayer_Private.hpp in Headers */, + 350098C61D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 353933FB1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h in Headers */, DA8847EF1CBAFA5100AB86E3 /* MGLAccountManager.h in Headers */, DA8848511CBAFB9800AB86E3 /* MGLAPIClient.h in Headers */, DA35A2C91CCAAAD200E826B2 /* NSValue+MGLAdditions.h in Headers */, + 350098CF1D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */, DA8848571CBAFB9800AB86E3 /* MGLMapboxEvents.h in Headers */, DA8848311CBAFA6200AB86E3 /* NSString+MGLAdditions.h in Headers */, + 353933F81D3FB79F003F57D7 /* MGLLineStyleLayer.h in Headers */, DA8847F41CBAFA5100AB86E3 /* MGLOfflinePack.h in Headers */, DA88482E1CBAFA6200AB86E3 /* NSException+MGLAdditions.h in Headers */, DA8848551CBAFB9800AB86E3 /* MGLLocationManager.h in Headers */, + 350098C11D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */, DA88483F1CBAFB8500AB86E3 /* MGLUserLocation.h in Headers */, DA88483D1CBAFB8500AB86E3 /* MGLMapView+IBAdditions.h in Headers */, - DA17BE301CC4BAC300402C41 /* MGLMapView_Internal.h in Headers */, + DA17BE301CC4BAC300402C41 /* MGLMapView_Private.hpp in Headers */, DAD165781CF4CDFF001FF4B9 /* MGLShapeCollection.h in Headers */, DA88481E1CBAFA6200AB86E3 /* MGLMultiPoint_Private.h in Headers */, + 3566C7661D4A77BA008152BC /* MGLGeoJSONSource.h in Headers */, + 35CE61821D4165D9004F2359 /* UIColor+MGLAdditions.hpp in Headers */, DA35A29E1CC9E94C00E826B2 /* MGLCoordinateFormatter.h in Headers */, DA8847F71CBAFA5100AB86E3 /* MGLOverlay.h in Headers */, DA35A2B11CCA141D00E826B2 /* MGLCompassDirectionFormatter.h in Headers */, + 350098D31D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h in Headers */, DA88488B1CBB037E00AB86E3 /* SMCalloutView.h in Headers */, DA8847FE1CBAFA5100AB86E3 /* MGLTypes.h in Headers */, DA8847F11CBAFA5100AB86E3 /* MGLGeometry.h in Headers */, DA8848221CBAFA6200AB86E3 /* MGLOfflineRegion_Private.h in Headers */, + 35136D4C1D4277FC00C20EFD /* MGLSource.h in Headers */, + 3566C76C1D4A8DFA008152BC /* MGLRasterSource.h in Headers */, DA8847F91CBAFA5100AB86E3 /* MGLPolygon.h in Headers */, DA8847F81CBAFA5100AB86E3 /* MGLPointAnnotation.h in Headers */, + 353933F21D3FB753003F57D7 /* MGLCircleStyleLayer.h in Headers */, DA8847F31CBAFA5100AB86E3 /* MGLMultiPoint.h in Headers */, DAD1656C1CF41981001FF4B9 /* MGLFeature.h in Headers */, 40EDA1C01CFE0E0200D9EA68 /* MGLAnnotationContainerView.h in Headers */, DA88484F1CBAFB9800AB86E3 /* MGLAnnotationImage_Private.h in Headers */, + 3534C7921D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp in Headers */, DA8847F21CBAFA5100AB86E3 /* MGLMapCamera.h in Headers */, + 3538AA1D1D542239008EC33D /* MGLBaseStyleLayer.h in Headers */, DA8847F51CBAFA5100AB86E3 /* MGLOfflineRegion.h in Headers */, DA737EE11D056A4E005BDA16 /* MGLMapViewDelegate.h in Headers */, DA8848851CBB033F00AB86E3 /* FABKitProtocol.h in Headers */, DA88481B1CBAFA6200AB86E3 /* MGLGeometry_Private.h in Headers */, DA88485C1CBAFB9800AB86E3 /* MGLUserLocationAnnotationView.h in Headers */, + 350098CA1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h in Headers */, + 350098AF1D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h in Headers */, DA8848871CBB033F00AB86E3 /* Fabric.h in Headers */, + 350098D81D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */, 35305D4A1D22AA6A0007D005 /* NSData+MGLAdditions.h in Headers */, DA8848841CBB033F00AB86E3 /* FABAttributes.h in Headers */, + 3538AA171D541C43008EC33D /* MGLStyleFilter.h in Headers */, DA8847FD1CBAFA5100AB86E3 /* MGLTilePyramidOfflineRegion.h in Headers */, DA88482F1CBAFA6200AB86E3 /* NSProcessInfo+MGLAdditions.h in Headers */, DA8848601CBAFC2E00AB86E3 /* Mapbox.h in Headers */, + 350098BB1D480108004B2AF0 /* MGLVectorSource.h in Headers */, + 3534C7951D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp in Headers */, DA8847F61CBAFA5100AB86E3 /* MGLOfflineStorage.h in Headers */, DAD1656E1CF41981001FF4B9 /* MGLFeature_Private.h in Headers */, DA88483C1CBAFB8500AB86E3 /* MGLMapView.h in Headers */, @@ -1039,36 +1387,68 @@ buildActionMask = 2147483647; files = ( DA35A2CA1CCAAAD200E826B2 /* NSValue+MGLAdditions.h in Headers */, + 350098BC1D480108004B2AF0 /* MGLVectorSource.h in Headers */, + 353933FC1D3FB7C0003F57D7 /* MGLRasterStyleLayer.h in Headers */, + 3566C76D1D4A8DFA008152BC /* MGLRasterSource.h in Headers */, + 35599DEC1D46F14E0048254D /* MGLStyleAttributeFunction.h in Headers */, DABFB85E1CBE99E500D62B32 /* MGLAnnotation.h in Headers */, + 350098D01D482E10004B2AF0 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */, DABFB8641CBE99E500D62B32 /* MGLOfflineStorage.h in Headers */, DAD165791CF4CDFF001FF4B9 /* MGLShapeCollection.h in Headers */, + 350098D41D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.h in Headers */, + 3566C7671D4A77BA008152BC /* MGLGeoJSONSource.h in Headers */, DA35A29F1CC9E94C00E826B2 /* MGLCoordinateFormatter.h in Headers */, DABFB8711CBE9A0F00D62B32 /* MGLMapView+MGLCustomStyleLayerAdditions.h in Headers */, DABFB8611CBE99E500D62B32 /* MGLMultiPoint.h in Headers */, + 35E0CFE71D3E501500188327 /* MGLStyle_Private.hpp in Headers */, DABFB86D1CBE9A0F00D62B32 /* MGLAnnotationImage.h in Headers */, DABFB8721CBE9A0F00D62B32 /* MGLUserLocation.h in Headers */, + 3566C7721D4A9198008152BC /* MGLSource_Private.hpp in Headers */, + 353933FF1D3FB7DD003F57D7 /* MGLSymbolStyleLayer.h in Headers */, DABFB8661CBE99E500D62B32 /* MGLPointAnnotation.h in Headers */, + 35599DF11D46F3A60048254D /* MGLStyleAttributeValue.h in Headers */, DABFB8621CBE99E500D62B32 /* MGLOfflinePack.h in Headers */, DAD1656D1CF41981001FF4B9 /* MGLFeature.h in Headers */, - DA17BE311CC4BDAA00402C41 /* MGLMapView_Internal.h in Headers */, + DA17BE311CC4BDAA00402C41 /* MGLMapView_Private.hpp in Headers */, DABFB86C1CBE99E500D62B32 /* MGLTypes.h in Headers */, + 350098C21D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */, DABFB8691CBE99E500D62B32 /* MGLShape.h in Headers */, + 350098CB1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.h in Headers */, DABFB8701CBE9A0F00D62B32 /* MGLMapView+IBAdditions.h in Headers */, + 350098D91D4830D5004B2AF0 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 35CE61831D4165D9004F2359 /* UIColor+MGLAdditions.hpp in Headers */, + 350098B01D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.h in Headers */, DABFB8671CBE99E500D62B32 /* MGLPolygon.h in Headers */, + 350098C71D48288B004B2AF0 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 3593E5221D529C29006D9365 /* MGLStyleAttribute.hpp in Headers */, DABFB8651CBE99E500D62B32 /* MGLOverlay.h in Headers */, + 35E79F211D41266300957B9E /* MGLStyleLayer_Private.hpp in Headers */, + 350098DD1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.h in Headers */, + 3534C7961D4BD1D400D874A4 /* MGLStyleAttributeValue_Private.hpp in Headers */, DABFB8681CBE99E500D62B32 /* MGLPolyline.h in Headers */, + 3534C7931D4BC95400D874A4 /* MGLStyleAttributeFunction_Private.hpp in Headers */, DABFB86F1CBE9A0F00D62B32 /* MGLMapView.h in Headers */, + 353933F31D3FB753003F57D7 /* MGLCircleStyleLayer.h in Headers */, + 3593E5271D529EDC006D9365 /* UIColor+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 3538AA1E1D542239008EC33D /* MGLBaseStyleLayer.h in Headers */, DABFB8631CBE99E500D62B32 /* MGLOfflineRegion.h in Headers */, DA35A2B21CCA141D00E826B2 /* MGLCompassDirectionFormatter.h in Headers */, DABFB8731CBE9A9900D62B32 /* Mapbox.h in Headers */, DABFB86B1CBE99E500D62B32 /* MGLTilePyramidOfflineRegion.h in Headers */, 4018B1CB1CDC288E00F666AF /* MGLAnnotationView.h in Headers */, DABFB85F1CBE99E500D62B32 /* MGLGeometry.h in Headers */, + 354D42DD1D4919F900F400A1 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 353933F61D3FB785003F57D7 /* MGLBackgroundStyleLayer.h in Headers */, DABFB85D1CBE99E500D62B32 /* MGLAccountManager.h in Headers */, + 353933F91D3FB79F003F57D7 /* MGLLineStyleLayer.h in Headers */, + 35D13AB81D3D15E300AFB4E0 /* MGLStyleLayer.h in Headers */, + 35136D4D1D4277FC00C20EFD /* MGLSource.h in Headers */, DA35A2BC1CCA9A6900E826B2 /* MGLClockDirectionFormatter.h in Headers */, + 35D13AC41D3D19DD00AFB4E0 /* MGLFillStyleLayer.h in Headers */, DABFB86E1CBE9A0F00D62B32 /* MGLCalloutView.h in Headers */, DABFB8601CBE99E500D62B32 /* MGLMapCamera.h in Headers */, DA737EE21D056A4E005BDA16 /* MGLMapViewDelegate.h in Headers */, + 3538AA181D541C43008EC33D /* MGLStyleFilter.h in Headers */, 353794D01D22B3BD002C281C /* NSData+MGLAdditions.h in Headers */, DABFB86A1CBE99E500D62B32 /* MGLStyle.h in Headers */, ); @@ -1288,6 +1668,7 @@ isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( + 353349B31D5CC6F20094E9DE /* amsterdam.geojson in Resources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -1374,11 +1755,19 @@ DA2E88631CC0382C00F24E7B /* MGLOfflineRegionTests.m in Sources */, DA2E88651CC0382C00F24E7B /* MGLStyleTests.mm in Sources */, DA2E88611CC0382C00F24E7B /* MGLGeometryTests.mm in Sources */, + 357579801D501E09000B822E /* MGLFillStyleLayerTests.m in Sources */, DA2E88641CC0382C00F24E7B /* MGLOfflineStorageTests.m in Sources */, + DA2DBBCE1D51E80400D38FF9 /* MGLStyleLayerTests.m in Sources */, DA35A2C61CCA9F8300E826B2 /* MGLCompassDirectionFormatterTests.m in Sources */, + 3575798E1D502EC7000B822E /* MGLRuntimeStylingHelper.m in Sources */, + 357579851D502AF5000B822E /* MGLSymbolStyleLayerTests.m in Sources */, + 357579871D502AFE000B822E /* MGLLineStyleLayerTests.m in Sources */, + 357579891D502B06000B822E /* MGLCircleStyleLayerTests.m in Sources */, DA35A2C51CCA9F8300E826B2 /* MGLClockDirectionFormatterTests.m in Sources */, + 3575798B1D502B0C000B822E /* MGLBackgroundStyleLayerTests.m in Sources */, DA2E88621CC0382C00F24E7B /* MGLOfflinePackTests.m in Sources */, DA35A2AA1CCA058D00E826B2 /* MGLCoordinateFormatterTests.m in Sources */, + 357579831D502AE6000B822E /* MGLRasterStyleLayerTests.m in Sources */, 353D23961D0B0DFE002BE09D /* MGLAnnotationViewTests.m in Sources */, 35E208A71D24210F00EC9A46 /* MGLNSDataAdditionsTests.m in Sources */, DA0CD5901CF56F6A00A5F5A5 /* MGLFeatureTests.mm in Sources */, @@ -1389,21 +1778,39 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 35136D391D42271A00C20EFD /* MGLBackgroundStyleLayer.mm in Sources */, + 350098D51D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm in Sources */, DA88485D1CBAFB9800AB86E3 /* MGLUserLocationAnnotationView.m in Sources */, + 3593E5231D529C29006D9365 /* MGLStyleAttribute.mm in Sources */, + 350098B11D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm in Sources */, DAD165701CF41981001FF4B9 /* MGLFeature.mm in Sources */, + 350098C31D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */, 40EDA1C11CFE0E0500D9EA68 /* MGLAnnotationContainerView.m in Sources */, DA8848541CBAFB9800AB86E3 /* MGLCompactCalloutView.m in Sources */, DA8848251CBAFA6200AB86E3 /* MGLPointAnnotation.m in Sources */, + 35136D3C1D42272500C20EFD /* MGLCircleStyleLayer.mm in Sources */, + 3538AA191D541C43008EC33D /* MGLStyleFilter.m in Sources */, + 350098DE1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */, + 3566C7681D4A77BA008152BC /* MGLGeoJSONSource.mm in Sources */, + 35136D421D42274500C20EFD /* MGLRasterStyleLayer.mm in Sources */, + 3538AA1F1D542239008EC33D /* MGLBaseStyleLayer.mm in Sources */, DA88482D1CBAFA6200AB86E3 /* NSBundle+MGLAdditions.m in Sources */, DA88485B1CBAFB9800AB86E3 /* MGLUserLocation.m in Sources */, + 350098BD1D480108004B2AF0 /* MGLVectorSource.m in Sources */, + 3566C76E1D4A8DFA008152BC /* MGLRasterSource.mm in Sources */, DA88488C1CBB037E00AB86E3 /* SMCalloutView.m in Sources */, + 35136D4E1D4277FC00C20EFD /* MGLSource.mm in Sources */, DA35A2B81CCA9A5D00E826B2 /* MGLClockDirectionFormatter.m in Sources */, DAD1657A1CF4CDFF001FF4B9 /* MGLShapeCollection.m in Sources */, + 350098CC1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */, + 35136D451D42275100C20EFD /* MGLSymbolStyleLayer.mm in Sources */, + 35599DED1D46F14E0048254D /* MGLStyleAttributeFunction.mm in Sources */, DA8848211CBAFA6200AB86E3 /* MGLOfflinePack.mm in Sources */, DA8848591CBAFB9800AB86E3 /* MGLMapView.mm in Sources */, DA8848501CBAFB9800AB86E3 /* MGLAnnotationImage.m in Sources */, DA8848281CBAFA6200AB86E3 /* MGLShape.m in Sources */, DA35A2B31CCA141D00E826B2 /* MGLCompassDirectionFormatter.m in Sources */, + 35D13AB91D3D15E300AFB4E0 /* MGLStyleLayer.mm in Sources */, DA35A2CB1CCAAAD200E826B2 /* NSValue+MGLAdditions.m in Sources */, DA8848321CBAFA6200AB86E3 /* NSString+MGLAdditions.m in Sources */, DA35A2A11CC9E95F00E826B2 /* MGLCoordinateFormatter.m in Sources */, @@ -1417,11 +1824,14 @@ DA8848261CBAFA6200AB86E3 /* MGLPolygon.mm in Sources */, DA8848521CBAFB9800AB86E3 /* MGLAPIClient.m in Sources */, DA8848301CBAFA6200AB86E3 /* NSProcessInfo+MGLAdditions.m in Sources */, + 35D13AC51D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm in Sources */, DA8848241CBAFA6200AB86E3 /* MGLOfflineStorage.mm in Sources */, DA88482A1CBAFA6200AB86E3 /* MGLTilePyramidOfflineRegion.mm in Sources */, + 35136D3F1D42273000C20EFD /* MGLLineStyleLayer.mm in Sources */, DA88481A1CBAFA6200AB86E3 /* MGLAccountManager.m in Sources */, DA8848271CBAFA6200AB86E3 /* MGLPolyline.mm in Sources */, DA8848581CBAFB9800AB86E3 /* MGLMapboxEvents.m in Sources */, + 35CE61841D4165D9004F2359 /* UIColor+MGLAdditions.mm in Sources */, DA8848561CBAFB9800AB86E3 /* MGLLocationManager.m in Sources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -1430,22 +1840,40 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 35136D3A1D42271A00C20EFD /* MGLBackgroundStyleLayer.mm in Sources */, + 350098D61D4830A6004B2AF0 /* NSString+MGLStyleAttributeAdditions.mm in Sources */, DAA4E4221CBB730400178DFB /* MGLPointAnnotation.m in Sources */, + 3593E5241D529C29006D9365 /* MGLStyleAttribute.mm in Sources */, + 350098B21D47E6F4004B2AF0 /* UIColor+MGLStyleAttributeAdditions.mm in Sources */, DAD165711CF41981001FF4B9 /* MGLFeature.mm in Sources */, + 350098C41D48149E004B2AF0 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */, 40EDA1C21CFE0E0500D9EA68 /* MGLAnnotationContainerView.m in Sources */, DAA4E4291CBB730400178DFB /* NSBundle+MGLAdditions.m in Sources */, DAA4E42E1CBB730400178DFB /* MGLAPIClient.m in Sources */, + 35136D3D1D42272500C20EFD /* MGLCircleStyleLayer.mm in Sources */, + 3538AA1A1D541C43008EC33D /* MGLStyleFilter.m in Sources */, + 350098DF1D484E60004B2AF0 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */, + 3566C7691D4A77BA008152BC /* MGLGeoJSONSource.mm in Sources */, + 35136D431D42274500C20EFD /* MGLRasterStyleLayer.mm in Sources */, + 3538AA201D542239008EC33D /* MGLBaseStyleLayer.mm in Sources */, DAA4E4201CBB730400178DFB /* MGLOfflinePack.mm in Sources */, DAA4E4331CBB730400178DFB /* MGLUserLocation.m in Sources */, + 350098BE1D480108004B2AF0 /* MGLVectorSource.m in Sources */, + 3566C76F1D4A8DFA008152BC /* MGLRasterSource.mm in Sources */, DAA4E4351CBB730400178DFB /* SMCalloutView.m in Sources */, + 35136D4F1D4277FC00C20EFD /* MGLSource.mm in Sources */, DA35A2B91CCA9A5D00E826B2 /* MGLClockDirectionFormatter.m in Sources */, DAD1657B1CF4CDFF001FF4B9 /* MGLShapeCollection.m in Sources */, + 350098CD1D482D9C004B2AF0 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */, DAA4E4251CBB730400178DFB /* MGLShape.m in Sources */, + 35136D461D42275100C20EFD /* MGLSymbolStyleLayer.mm in Sources */, + 35599DEE1D46F14E0048254D /* MGLStyleAttributeFunction.mm in Sources */, DAA4E42B1CBB730400178DFB /* NSString+MGLAdditions.m in Sources */, DAA4E4261CBB730400178DFB /* MGLStyle.mm in Sources */, DAA4E41D1CBB730400178DFB /* MGLGeometry.mm in Sources */, DAA4E41F1CBB730400178DFB /* MGLMultiPoint.mm in Sources */, DA35A2B41CCA141D00E826B2 /* MGLCompassDirectionFormatter.m in Sources */, + 35D13ABA1D3D15E300AFB4E0 /* MGLStyleLayer.mm in Sources */, DA35A2CC1CCAAAD200E826B2 /* NSValue+MGLAdditions.m in Sources */, DAA4E4281CBB730400178DFB /* MGLTypes.m in Sources */, DA35A2A21CC9E95F00E826B2 /* MGLCoordinateFormatter.m in Sources */, @@ -1458,11 +1886,14 @@ DAA4E4341CBB730400178DFB /* MGLUserLocationAnnotationView.m in Sources */, DAA4E4311CBB730400178DFB /* MGLMapboxEvents.m in Sources */, DAA4E4231CBB730400178DFB /* MGLPolygon.mm in Sources */, + 35D13AC61D3D19DD00AFB4E0 /* MGLFillStyleLayer.mm in Sources */, DAA4E42A1CBB730400178DFB /* NSProcessInfo+MGLAdditions.m in Sources */, DAA4E4211CBB730400178DFB /* MGLOfflineStorage.mm in Sources */, + 35136D401D42273000C20EFD /* MGLLineStyleLayer.mm in Sources */, DAA4E42F1CBB730400178DFB /* MGLCompactCalloutView.m in Sources */, DAA4E4271CBB730400178DFB /* MGLTilePyramidOfflineRegion.mm in Sources */, DAA4E41C1CBB730400178DFB /* MGLAccountManager.m in Sources */, + 35CE61851D4165D9004F2359 /* UIColor+MGLAdditions.mm in Sources */, DAA4E4241CBB730400178DFB /* MGLPolyline.mm in Sources */, ); runOnlyForDeploymentPostprocessing = 0; diff --git a/platform/ios/src/MGLAnnotationView.mm b/platform/ios/src/MGLAnnotationView.mm index 7064ccbd76..3ee7bb06c1 100644 --- a/platform/ios/src/MGLAnnotationView.mm +++ b/platform/ios/src/MGLAnnotationView.mm @@ -1,7 +1,7 @@ #import "MGLAnnotationView.h" #import "MGLAnnotationView_Private.h" +#import "MGLMapView_Private.hpp" #import "MGLAnnotation.h" -#import "MGLMapView_Internal.h" #import "NSBundle+MGLAdditions.h" diff --git a/platform/ios/src/MGLMapView.h b/platform/ios/src/MGLMapView.h index 56236c54d8..25967a9291 100644 --- a/platform/ios/src/MGLMapView.h +++ b/platform/ios/src/MGLMapView.h @@ -14,6 +14,7 @@ NS_ASSUME_NONNULL_BEGIN @class MGLPolyline; @class MGLPolygon; @class MGLShape; +@class MGLStyle; @protocol MGLMapViewDelegate; @protocol MGLAnnotation; @@ -1087,6 +1088,10 @@ IB_DESIGNABLE */ - (void)removeOverlays:(NS_ARRAY_OF(id <MGLOverlay>) *)overlays; +#pragma mark - Runtime styling API + +- (MGLStyle *)style; + #pragma mark Accessing the Underlying Map Data /** diff --git a/platform/ios/src/MGLMapView.mm b/platform/ios/src/MGLMapView.mm index 09eb2319a2..fa885d020d 100644 --- a/platform/ios/src/MGLMapView.mm +++ b/platform/ios/src/MGLMapView.mm @@ -1,4 +1,4 @@ -#import "MGLMapView_Internal.h" +#import "MGLMapView_Private.hpp" #import <mbgl/platform/log.hpp> #import <mbgl/gl/gl.hpp> @@ -35,10 +35,13 @@ #import "NSString+MGLAdditions.h" #import "NSProcessInfo+MGLAdditions.h" #import "NSException+MGLAdditions.h" +#import "UIColor+MGLAdditions.hpp" #import "MGLUserLocationAnnotationView.h" #import "MGLUserLocation_Private.h" #import "MGLAnnotationImage_Private.h" #import "MGLAnnotationView_Private.h" +#import "MGLStyle_Private.hpp" +#import "MGLStyleLayer_Private.hpp" #import "MGLMapboxEvents.h" #import "MGLCompactCalloutView.h" #import "MGLAnnotationContainerView.h" @@ -131,17 +134,6 @@ mbgl::util::UnitBezier MGLUnitBezierForMediaTimingFunction(CAMediaTimingFunction return { p1[0], p1[1], p2[0], p2[1] }; } -mbgl::Color MGLColorObjectFromUIColor(UIColor *color) -{ - if (!color) - { - return { 0, 0, 0, 0 }; - } - CGFloat r, g, b, a; - [color getRed:&r green:&g blue:&b alpha:&a]; - return { (float)r, (float)g, (float)b, (float)a }; -} - @interface MGLAnnotationAccessibilityElement : UIAccessibilityElement @property (nonatomic) MGLAnnotationTag tag; @@ -611,6 +603,13 @@ mbgl::Duration MGLDurationInSeconds(NSTimeInterval duration) return image; } +- (MGLStyle *)style +{ + MGLStyle *style = [[MGLStyle alloc] init]; + style.mapView = self; + return style; +} + - (void)reachabilityChanged:(NSNotification *)notification { MGLReachability *reachability = [notification object]; @@ -3046,7 +3045,7 @@ mbgl::Duration MGLDurationInSeconds(NSTimeInterval duration) UIColor *color = (_delegateHasStrokeColorsForShapeAnnotations ? [self.delegate mapView:self strokeColorForShapeAnnotation:annotation] : self.tintColor); - return MGLColorObjectFromUIColor(color); + return color.mbgl_color; } - (mbgl::Color)fillColorForPolygonAnnotation:(MGLPolygon *)annotation @@ -3054,7 +3053,7 @@ mbgl::Duration MGLDurationInSeconds(NSTimeInterval duration) UIColor *color = (_delegateHasFillColorsForShapeAnnotations ? [self.delegate mapView:self fillColorForPolygonAnnotation:annotation] : self.tintColor); - return MGLColorObjectFromUIColor(color); + return color.mbgl_color; } - (CGFloat)lineWidthForPolylineAnnotation:(MGLPolyline *)annotation @@ -5160,4 +5159,8 @@ void MGLFinishCustomStyleLayer(void *context) _mbglMap->update(mbgl::Update::Repaint); } +- (mbgl::Map *)mbglMap { + return _mbglMap; +} + @end diff --git a/platform/ios/src/MGLMapView_Internal.h b/platform/ios/src/MGLMapView_Private.hpp index 9133aca857..5c74ba6dc8 100644 --- a/platform/ios/src/MGLMapView_Internal.h +++ b/platform/ios/src/MGLMapView_Private.hpp @@ -1,5 +1,7 @@ #import <Mapbox/Mapbox.h> +#include <mbgl/mbgl.hpp> + /// Minimum size of an annotation’s accessibility element. extern const CGSize MGLAnnotationAccessibilityElementMinimumSize; @@ -11,6 +13,8 @@ extern const CGSize MGLAnnotationAccessibilityElementMinimumSize; /** Triggers another render pass even when it is not necessary. */ - (void)setNeedsGLDisplay; +- (mbgl::Map *)mbglMap; + /** Returns whether the map view is currently loading or processing any assets required to render the map */ - (BOOL)isFullyLoaded; diff --git a/platform/ios/src/Mapbox.h b/platform/ios/src/Mapbox.h index bc22a5f955..d6c05503e9 100644 --- a/platform/ios/src/Mapbox.h +++ b/platform/ios/src/Mapbox.h @@ -32,7 +32,26 @@ FOUNDATION_EXPORT const unsigned char MapboxVersionString[]; #import "MGLShape.h" #import "MGLShapeCollection.h" #import "MGLStyle.h" +#import "MGLStyleLayer.h" +#import "MGLBaseStyleLayer.h" +#import "MGLFillStyleLayer.h" +#import "MGLLineStyleLayer.h" +#import "MGLSymbolStyleLayer.h" +#import "MGLRasterStyleLayer.h" +#import "MGLCircleStyleLayer.h" +#import "MGLBackgroundStyleLayer.h" +#import "MGLSource.h" +#import "MGLVectorSource.h" +#import "MGLGeoJSONSource.h" +#import "MGLRasterSource.h" #import "MGLTilePyramidOfflineRegion.h" #import "MGLTypes.h" #import "MGLUserLocation.h" #import "NSValue+MGLAdditions.h" +#import "MGLStyleAttributeValue.h" +#import "MGLStyleAttributeFunction.h" +#import "UIColor+MGLStyleAttributeAdditions.h" +#import "NSNumber+MGLStyleAttributeAdditions.h" +#import "NSValue+MGLStyleAttributeAdditions.h" +#import "NSString+MGLStyleAttributeAdditions.h" +#import "NSArray+MGLStyleAttributeAdditions.h" diff --git a/platform/ios/src/UIColor+MGLAdditions.hpp b/platform/ios/src/UIColor+MGLAdditions.hpp new file mode 100644 index 0000000000..7cc291c657 --- /dev/null +++ b/platform/ios/src/UIColor+MGLAdditions.hpp @@ -0,0 +1,14 @@ +#import <UIKit/UIKit.h> + +#include <mbgl/util/color.hpp> +#include <mbgl/style/property_value.hpp> + +@interface UIColor (MGLAdditions) + +- (mbgl::Color)mbgl_color; + +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue; + ++ (UIColor *)mbgl_colorWithColor:(mbgl::Color)color; + +@end diff --git a/platform/ios/src/UIColor+MGLAdditions.mm b/platform/ios/src/UIColor+MGLAdditions.mm new file mode 100644 index 0000000000..23aea162f7 --- /dev/null +++ b/platform/ios/src/UIColor+MGLAdditions.mm @@ -0,0 +1,26 @@ +#import "UIColor+MGLAdditions.hpp" + +#import "MGLStyleAttributeValue.h" +#import "MGLStyleAttributeValue_Private.hpp" + +@implementation UIColor (MGLAdditions) + +- (mbgl::Color)mbgl_color +{ + CGFloat r, g, b, a; + [self getRed:&r green:&g blue:&b alpha:&a]; + return { (float)r, (float)g, (float)b, (float)a }; +} + +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue +{ + mbgl::Color color = self.mbgl_color; + return {{ color.r, color.g, color.b, color.a }}; +} + ++ (UIColor *)mbgl_colorWithColor:(mbgl::Color)color +{ + return [UIColor colorWithRed:color.r green:color.g blue:color.b alpha:color.a]; +} + +@end diff --git a/platform/ios/src/UIColor+MGLStyleAttributeAdditions.h b/platform/ios/src/UIColor+MGLStyleAttributeAdditions.h new file mode 100644 index 0000000000..3637ceab6c --- /dev/null +++ b/platform/ios/src/UIColor+MGLStyleAttributeAdditions.h @@ -0,0 +1,7 @@ +#import <UIKit/UIKit.h> + +#import "MGLStyleAttributeValue.h" + +@interface UIColor (MGLStyleAttributeAdditions) <MGLStyleAttributeValue> + +@end diff --git a/platform/ios/src/UIColor+MGLStyleAttributeAdditions.mm b/platform/ios/src/UIColor+MGLStyleAttributeAdditions.mm new file mode 100644 index 0000000000..f8c649c40b --- /dev/null +++ b/platform/ios/src/UIColor+MGLStyleAttributeAdditions.mm @@ -0,0 +1,14 @@ +#import "UIColor+MGLStyleAttributeAdditions.h" + +#import "MGLStyleAttributeValue.h" +#import "MGLStyleAttributeValue_Private.hpp" +#import "UIColor+MGLAdditions.hpp" + +@implementation UIColor (MGLStyleAttributeAdditions) + +- (BOOL)isFunction +{ + return NO; +} + +@end diff --git a/platform/ios/test/MGLStyleLayerTests.xib b/platform/ios/test/MGLStyleLayerTests.xib new file mode 100644 index 0000000000..a094768329 --- /dev/null +++ b/platform/ios/test/MGLStyleLayerTests.xib @@ -0,0 +1,39 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="11185.3" systemVersion="15G31" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct"> + <dependencies> + <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11185.3"/> + </dependencies> + <objects> + <customObject id="-2" userLabel="File's Owner" customClass="MGLStyleLayerTests"> + <connections> + <outlet property="mapView" destination="6RL-d9-juy" id="0ch-aR-Um6"/> + </connections> + </customObject> + <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/> + <customObject id="-3" userLabel="Application" customClass="NSObject"/> + <window title="MGLStyleLayerTests" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" animationBehavior="default" id="QvC-M9-y7g"> + <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/> + <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/> + <rect key="contentRect" x="196" y="240" width="256" height="256"/> + <rect key="screenRect" x="0.0" y="0.0" width="1280" height="777"/> + <view key="contentView" wantsLayer="YES" id="EiT-Mj-1SZ"> + <rect key="frame" x="0.0" y="0.0" width="256" height="256"/> + <autoresizingMask key="autoresizingMask"/> + <subviews> + <customView translatesAutoresizingMaskIntoConstraints="NO" id="6RL-d9-juy" customClass="MGLMapView"> + <rect key="frame" x="0.0" y="0.0" width="256" height="256"/> + <connections> + <outlet property="delegate" destination="-2" id="6kS-ct-JEg"/> + </connections> + </customView> + </subviews> + <constraints> + <constraint firstItem="6RL-d9-juy" firstAttribute="leading" secondItem="EiT-Mj-1SZ" secondAttribute="leading" id="KEN-aL-UF0"/> + <constraint firstAttribute="bottom" secondItem="6RL-d9-juy" secondAttribute="bottom" id="V27-f3-xHZ"/> + <constraint firstAttribute="trailing" secondItem="6RL-d9-juy" secondAttribute="trailing" id="vjq-iM-OyA"/> + <constraint firstItem="6RL-d9-juy" firstAttribute="top" secondItem="EiT-Mj-1SZ" secondAttribute="top" id="yWg-v4-wJB"/> + </constraints> + </view> + </window> + </objects> +</document> diff --git a/platform/ios/test/amsterdam.geojson b/platform/ios/test/amsterdam.geojson new file mode 100644 index 0000000000..a0e28a8e9e --- /dev/null +++ b/platform/ios/test/amsterdam.geojson @@ -0,0 +1,2283 @@ +{ + "type": "FeatureCollection", + "features": [ + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Westerpark", + "type": "park", + "description": "The \"Westerpark\" is a public urban park in Amsterdam, Netherlands. The former borough of Westerpark is named after the park, as is the current neighborhood. The verdant space of the former Westergasfabriek (gasworks) along Haarlemmerweg has become a place for cultural avant-garde businesses and events. The park is stretched along the railway, offering a biotope area to experience nature in the city. In addition Westerpark is home to one of the Netherlands’ oldest volkstuin (Gardenpark)." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.88093376159668, + 52.38560608655206 + ], + [ + 4.881706237792968, + 52.3864966440161 + ], + [ + 4.870891571044922, + 52.388696767789725 + ], + [ + 4.864625930786133, + 52.38906344442449 + ], + [ + 4.85072135925293, + 52.389220590621235 + ], + [ + 4.846086502075195, + 52.38864438516467 + ], + [ + 4.84522819519043, + 52.38607756038855 + ], + [ + 4.845314025878906, + 52.38560608655206 + ], + [ + 4.84745979309082, + 52.38560608655206 + ], + [ + 4.848232269287109, + 52.38518699447024 + ], + [ + 4.88093376159668, + 52.38560608655206 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "vondelpark", + "type": "park", + "description": "Vondelpark has opened its gates since 1885 and is Amsterdam's busiest park, with 10 Million visitors per year, situated at the south-west corner of the canal ring. It is very popular in summer for both tourists and locals, and all year round as a training area for runners, with many bootcamps taking place all over the park." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.881491661071777, + 52.36194735288177 + ], + [ + 4.882135391235352, + 52.361711487760196 + ], + [ + 4.882307052612305, + 52.361475621379526 + ], + [ + 4.875826835632324, + 52.35966727063089 + ], + [ + 4.875226020812988, + 52.35846166234964 + ], + [ + 4.866771697998047, + 52.356207610808546 + ], + [ + 4.867458343505859, + 52.355159175569305 + ], + [ + 4.86668586730957, + 52.35497569684526 + ], + [ + 4.864239692687988, + 52.35563097450493 + ], + [ + 4.861965179443359, + 52.35578823969753 + ], + [ + 4.858918190002441, + 52.35437283281734 + ], + [ + 4.857029914855957, + 52.35468737159704 + ], + [ + 4.855892658233642, + 52.354634948622525 + ], + [ + 4.855034351348877, + 52.356391084418235 + ], + [ + 4.875226020812988, + 52.36126596131745 + ], + [ + 4.876556396484375, + 52.360453519180375 + ], + [ + 4.881491661071777, + 52.36194735288177 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Jordaan", + "type": "neighborhood", + "description": "The Jordan was originally a working-class neighbourhood, and has now become a more upscale neighborhood. It is home to many art galleries, particularly for modern art, and is also dotted with speciality shops and restaurants. Markets are held regularly at Noordermarkt, the Westerstraat and Lindengracht." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.888465404510498, + 52.38053742479665 + ], + [ + 4.883208274841309, + 52.374865596670936 + ], + [ + 4.882457256317139, + 52.36667749309006 + ], + [ + 4.882757663726807, + 52.36619270976844 + ], + [ + 4.879302978515624, + 52.36490866337324 + ], + [ + 4.874324798583984, + 52.37186565170666 + ], + [ + 4.8818135261535645, + 52.38427021667093 + ], + [ + 4.888465404510498, + 52.38053742479665 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Prinseneiland", + "type": "neighborhood", + "description": "Between 1610 and 1615 Prinseneiland was built as an extension of the harbor. Until the end of the 19th century this was an area with many wharfs, little industries and warehouses, related to the shipping trades. After the second World war the desolated area was discovered by many artists, who established their homes and studios in the vacant buildings. During the second half of the 20th century the old warehouses were transformed into apartments one after another, and new apartments were built. Nevertheless a lot of the atmosphere of the glorious past is still present in the old buildings and wooden drawbridges." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.883251190185547, + 52.38618233166844 + ], + [ + 4.889817237854004, + 52.38264616355127 + ], + [ + 4.896254539489746, + 52.38356297507495 + ], + [ + 4.891490936279297, + 52.390425359543386 + ], + [ + 4.884967803955078, + 52.39068726147953 + ], + [ + 4.883251190185547, + 52.38618233166844 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Sarphatipark", + "type": "park", + "description": "Sarphatipark is a small park in the popular De Pijp neighbourhood. It was openend in late 19th century, and named after Samuel Sarphati." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.894580841064453, + 52.35337022551748 + ], + [ + 4.899033308029174, + 52.354267986060016 + ], + [ + 4.89815354347229, + 52.35544094498385 + ], + [ + 4.893786907196045, + 52.35446457352601 + ], + [ + 4.894580841064453, + 52.35337022551748 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Museumsplein", + "type": "area", + "description": "Museumplein is a large open space which hosts different events throughout the year. Along the edges of the open square, some of the Dutch capitals most important art museums, such as Stedelijk Museum, Van Gogh Museum and Rijksmuseum." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.880322217941284, + 52.35625347928239 + ], + [ + 4.881459474563598, + 52.35610932106146 + ], + [ + 4.882693290710448, + 52.356921843071525 + ], + [ + 4.883508682250977, + 52.357996446011384 + ], + [ + 4.884324073791504, + 52.35783263627572 + ], + [ + 4.884721040725708, + 52.35903498560687 + ], + [ + 4.886341094970703, + 52.35875651523955 + ], + [ + 4.886770248413086, + 52.36003418836164 + ], + [ + 4.884881973266602, + 52.36113492327348 + ], + [ + 4.884538650512695, + 52.36066318309746 + ], + [ + 4.883229732513428, + 52.36028971855292 + ], + [ + 4.883841276168823, + 52.35953622784582 + ], + [ + 4.882038831710815, + 52.35897929167382 + ], + [ + 4.882339239120483, + 52.35861236518361 + ], + [ + 4.880794286727905, + 52.35790471263422 + ], + [ + 4.880847930908203, + 52.357780217032044 + ], + [ + 4.879699945449829, + 52.35691529053445 + ], + [ + 4.880322217941284, + 52.35625347928239 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Marineterrein", + "type": "area", + "description": "The Marineterrein exists already for more than 350 years. The area lies on the island known as ‘Kattenburg’, in close vicinity to Centraal Station and Amsterdam’s Maritime Museum. During the Golden Age the VOC used this area to build large warships. After years of use through the Dutch marines, the area has now been opened for the public and workspaces are filled by tech startups." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.914064407348633, + 52.37083068892153 + ], + [ + 4.917154312133789, + 52.37187875234601 + ], + [ + 4.921102523803711, + 52.37444640263532 + ], + [ + 4.921188354492187, + 52.37481319763409 + ], + [ + 4.914150238037109, + 52.37586116655898 + ], + [ + 4.913034439086914, + 52.374917995645625 + ], + [ + 4.914493560791016, + 52.37339840013861 + ], + [ + 4.914064407348633, + 52.37083068892153 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "erasmuspark" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.849905967712402, + 52.37300539279099 + ], + [ + 4.852695465087891, + 52.37350320150736 + ], + [ + 4.855098724365234, + 52.37428920384616 + ], + [ + 4.854240417480469, + 52.3765423330248 + ], + [ + 4.848318099975586, + 52.37552057938607 + ], + [ + 4.849905967712402, + 52.37300539279099 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Sloterdijk", + "type": "area", + "description": "To protect the area around Sloten from the as-yet undrained IJ the Spaarndammerdijk was laid along the south bank of this inlet. In this vicinity at the same time, a dam on the Slochter (or Slooter) river was built, the Slooterdam. Trade grew in the vicinity, and in the 15th century a weigh house and a church were built. The area is nowadays best known as a large intersection of train lines and a business and industrial centre north-west of Amsterdam." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.8665571212768555, + 52.39312287505632 + ], + [ + 4.849648475646973, + 52.400638383557414 + ], + [ + 4.845571517944336, + 52.39681532315127 + ], + [ + 4.8445844650268555, + 52.39411803332277 + ], + [ + 4.844756126403809, + 52.38911582655221 + ], + [ + 4.85072135925293, + 52.38935154535783 + ], + [ + 4.871063232421875, + 52.389299163509826 + ], + [ + 4.8665571212768555, + 52.39312287505632 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Nine Streets (Negen Straatjes)", + "type": "poi", + "description": "De Negen Straatjes (Dutch for \"the nine little streets\") are nine side streets of the Prinsengracht, Keizersgracht, Herengracht and Singel in central Amsterdam which have been promoting themselves with that name since the 1990s. Together they form a sub-neighborhood within the larger western Grachtengordel (\"Canal Belt\"), one with many small and diverse shops and restaurants. The construction in this area goes back to the first half of the 17th century." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.887650012969971, + 52.368629674781644 + ], + [ + 4.8884546756744385, + 52.37242897568859 + ], + [ + 4.883047342300415, + 52.372664783594274 + ], + [ + 4.882628917694092, + 52.36839384533322 + ], + [ + 4.887650012969971, + 52.368629674781644 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Artis", + "type": "poi", + "description": "Artis, short for Natura Artis Magistra (Latin for \"Nature is the teacher of art and science\"), is a zoo in the centre of Amsterdam. It is the oldest zoo in the Netherlands and one of the oldest zoos of mainland Europe. Artis Royal Zoo is not just a zoo, it also contains an aquarium and a planetarium. Artis also has an arboretum and a fairly large art collection. A part of the art collection is on display in the Aquarium building of the zoo. Artis contains 27 monumental buildings, most of which are used as enclosures for the animals, making Artis a unique cultural heritage of the 19th century." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.911768436431885, + 52.36642855096776 + ], + [ + 4.913313388824463, + 52.36802699702209 + ], + [ + 4.916939735412598, + 52.36679541255308 + ], + [ + 4.9175190925598145, + 52.3673456992188 + ], + [ + 4.921274185180664, + 52.366048583971256 + ], + [ + 4.921660423278808, + 52.36551138367574 + ], + [ + 4.918656349182129, + 52.36400456750192 + ], + [ + 4.911768436431885, + 52.36642855096776 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Oosterpark", + "type": "park", + "description": "Oosterpark was the first large park opened by the municipality of Amsterdam in 1891. The park was designed as an English garden by Dutch landscape architect Leonard Anthony Springer." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.915802478790282, + 52.36062387118878 + ], + [ + 4.9173688888549805, + 52.35804231262857 + ], + [ + 4.925351142883301, + 52.36002108420944 + ], + [ + 4.923892021179199, + 52.36192114570822 + ], + [ + 4.92213249206543, + 52.36150182881734 + ], + [ + 4.92161750793457, + 52.36223563076494 + ], + [ + 4.919493198394775, + 52.36159355472725 + ], + [ + 4.91987943649292, + 52.36101698870163 + ], + [ + 4.918956756591797, + 52.360741806809884 + ], + [ + 4.918656349182129, + 52.36097767710775 + ], + [ + 4.917240142822266, + 52.36063697516221 + ], + [ + 4.916982650756836, + 52.360899053815025 + ], + [ + 4.915802478790282, + 52.36062387118878 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Park Frankendael", + "type": "park", + "description": "As Amsterdam rapidly grew in the sixteen and the beginning of eighteen century, the real estate in the city became so expensive, that rich people who wanted to enjoy a bigger property had to move further from the capital. The Park Frankendael (7 acres) in East Amsterdam, was originally one of these wealthy estates. The entrance to the park with an old ornamented gate is at the Middenweg, less than one mile (1300m) from the Tropenmuseum, driving out of the city. The beautiful old land house Frankendael (built in 1659) is visible from the street – it is one of the few of these estates remaining in Amsterdam" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.925265312194824, + 52.35007391180776 + ], + [ + 4.9283552169799805, + 52.352079253210675 + ], + [ + 4.930479526519775, + 52.3535995821349 + ], + [ + 4.93483543395996, + 52.35080790353051 + ], + [ + 4.929170608520508, + 52.34772767795072 + ], + [ + 4.925265312194824, + 52.35007391180776 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Stedelijk Museum", + "type": "poi", + "description": "Colloquially known as the Stedelijk, it is a museum for modern art, contemporary art, and design. The 19th century building was designed by Adriaan Willem Weissman and the 21st century wing with the current entrance was designed by Benthem Crouwel Architects. The collection comprises art from the early 20th century up to the 21st century. " + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.879399538040161, + 52.357400175655954 + ], + [ + 4.88067626953125, + 52.3577933218488 + ], + [ + 4.880236387252808, + 52.35841579616774 + ], + [ + 4.8789381980896, + 52.35808817919812 + ], + [ + 4.879399538040161, + 52.357400175655954 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Rembrandtpark", + "type": "park", + "description": "Rembrandtpark is a hidden gem west of the 'famous' Vondelpark. It is often not known to tourists and expats, but loved by locals for the outdoor gym and kids' playgrounds. It's great to combine both, Vondelpark and Rembrandtpark on a run or walk." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.845314025878906, + 52.369179938598464 + ], + [ + 4.84522819519043, + 52.36763394187947 + ], + [ + 4.843039512634277, + 52.36755533043126 + ], + [ + 4.8429107666015625, + 52.36490866337324 + ], + [ + 4.8442840576171875, + 52.36456799173892 + ], + [ + 4.84419822692871, + 52.36323148534417 + ], + [ + 4.843082427978516, + 52.36302183361385 + ], + [ + 4.843254089355469, + 52.36019143788499 + ], + [ + 4.844799041748047, + 52.36027006243683 + ], + [ + 4.8451852798461905, + 52.35924793235075 + ], + [ + 4.843854904174805, + 52.35888100809126 + ], + [ + 4.844112396240234, + 52.35822577862119 + ], + [ + 4.848747253417969, + 52.35825198798652 + ], + [ + 4.8487043380737305, + 52.36079422254044 + ], + [ + 4.849519729614258, + 52.361292168879636 + ], + [ + 4.849262237548828, + 52.363572167284175 + ], + [ + 4.850249290466309, + 52.3637031981001 + ], + [ + 4.850249290466309, + 52.36540656334422 + ], + [ + 4.8484039306640625, + 52.369546777334904 + ], + [ + 4.845314025878906, + 52.369179938598464 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Sloterpark", + "type": "park", + "description": "Amsterdam's largest park is Sloter Park with 91 hectares. It was created in the 1950s using excavated soil of the former Sloterdijkermeer Polder." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.823555946350098, + 52.3639652585661 + ], + [ + 4.826860427856445, + 52.36414869996741 + ], + [ + 4.826817512512207, + 52.36585204803552 + ], + [ + 4.830508232116699, + 52.370280445668364 + ], + [ + 4.826602935791016, + 52.373031593389626 + ], + [ + 4.822740554809569, + 52.37360800262741 + ], + [ + 4.821324348449707, + 52.37235037277361 + ], + [ + 4.819135665893555, + 52.371695343041914 + ], + [ + 4.81201171875, + 52.37187875234601 + ], + [ + 4.807548522949219, + 52.372402774732464 + ], + [ + 4.805660247802734, + 52.37046386084771 + ], + [ + 4.80926513671875, + 52.36349354860812 + ], + [ + 4.8105525970458975, + 52.36328389812132 + ], + [ + 4.8113250732421875, + 52.36150182881734 + ], + [ + 4.807033538818359, + 52.360899053815025 + ], + [ + 4.809608459472655, + 52.35654834690599 + ], + [ + 4.815659523010254, + 52.3577540073869 + ], + [ + 4.818663597106934, + 52.357963684112846 + ], + [ + 4.818620681762695, + 52.359483810623004 + ], + [ + 4.823555946350098, + 52.3639652585661 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amsterdamse Bos", + "type": "park", + "description": "Every year almost 4.5 million people visit the Amsterdamse Bos, which has a size of 1,000 hectares and is approximately three times the size of New York's Central Park. The park was designed as a landscape park and is great for running, walking and cycling." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.849991798400879, + 52.33090717211467 + ], + [ + 4.849863052368164, + 52.331746382485676 + ], + [ + 4.853982925415039, + 52.33187750766789 + ], + [ + 4.853467941284179, + 52.332323330379836 + ], + [ + 4.848232269287109, + 52.33258557693488 + ], + [ + 4.848318099975586, + 52.33321496232317 + ], + [ + 4.8319244384765625, + 52.33145790571652 + ], + [ + 4.8181915283203125, + 52.330828495326095 + ], + [ + 4.820079803466797, + 52.32327487205222 + ], + [ + 4.816474914550781, + 52.31299147898779 + ], + [ + 4.813899993896484, + 52.30879348896445 + ], + [ + 4.809093475341796, + 52.30585465906291 + ], + [ + 4.824028015136719, + 52.29000260620264 + ], + [ + 4.832954406738281, + 52.29441235610253 + ], + [ + 4.8427391052246085, + 52.29220753602784 + ], + [ + 4.844627380371094, + 52.30060626328963 + ], + [ + 4.842395782470703, + 52.30396530825102 + ], + [ + 4.842395782470703, + 52.30407027430016 + ], + [ + 4.839649200439453, + 52.30504119845803 + ], + [ + 4.841108322143555, + 52.30732409839935 + ], + [ + 4.840335845947266, + 52.31708413595253 + ], + [ + 4.848575592041015, + 52.317189070898415 + ], + [ + 4.8558712005615225, + 52.31645452105213 + ], + [ + 4.8566436767578125, + 52.323484712336324 + ], + [ + 4.856557846069336, + 52.32757639896581 + ], + [ + 4.855785369873047, + 52.33085472093785 + ], + [ + 4.849991798400879, + 52.33090717211467 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amstelpark", + "type": "park", + "description": "The Amstelpark is a park in Amsterdam-Zuid. The park includes a labyrinth, a café, a restaurant, two galleries, an orangery, petting zoo and a mini-golf course. The Amstelpark was built and opened for the 1972 Floriade gardening exhibition. The park offers the Amstel train which runs through the Rosarium, the rhododendron valley and the Riekermolen. The park lost about 30 percent of its larger trees due to disease. The rhododendron valley contains about 139 species of rhododendrons, blooming between April and May. At the Great Pond in the park is the Japanese Garden. At the time of the celebration of the 400-year relationship between the Netherlands and Japan in 2001, the gardens were renovated." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.892907142639159, + 52.32445521070514 + ], + [ + 4.891705513000488, + 52.325110940795255 + ], + [ + 4.890632629394531, + 52.32513716979672 + ], + [ + 4.89041805267334, + 52.3336869954871 + ], + [ + 4.892778396606445, + 52.33373944330546 + ], + [ + 4.894108772277832, + 52.333949233956965 + ], + [ + 4.897370338439941, + 52.33255935234935 + ], + [ + 4.897799491882323, + 52.33085472093785 + ], + [ + 4.897327423095702, + 52.32907134391899 + ], + [ + 4.895954132080078, + 52.32734035040776 + ], + [ + 4.894537925720215, + 52.32458635750065 + ], + [ + 4.892907142639159, + 52.32445521070514 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Martin Luther Kingpark", + "type": "park", + "description": "Martin Luther Kingpark is part of the Rivierenbuurt and has been renamed from Amstelpark, after the new Amstelpark in Buitenveldert was created. The park hosts the famous theater festival Parade every year in summer since the 1990s. " + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.906554222106933, + 52.33813172737753 + ], + [ + 4.906167984008789, + 52.33685997655858 + ], + [ + 4.90389347076416, + 52.33743685775091 + ], + [ + 4.901747703552246, + 52.33821039117558 + ], + [ + 4.901790618896484, + 52.3400982803501 + ], + [ + 4.90689754486084, + 52.34004584007248 + ], + [ + 4.905717372894287, + 52.33836771835187 + ], + [ + 4.906554222106933, + 52.33813172737753 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Beatrixpark", + "type": "park", + "description": "Beatrixpark, named after Queen Beatrix is located in the borough of Amsterdam-Zuid." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.87818717956543, + 52.34435884510934 + ], + [ + 4.88093376159668, + 52.34582700615622 + ], + [ + 4.882993698120117, + 52.34456858538671 + ], + [ + 4.8854827880859375, + 52.34435884510934 + ], + [ + 4.884710311889648, + 52.33984918847747 + ], + [ + 4.882392883300781, + 52.33995406943698 + ], + [ + 4.879045486450195, + 52.33984918847747 + ], + [ + 4.878787994384765, + 52.340688229188224 + ], + [ + 4.881620407104492, + 52.34074066870404 + ], + [ + 4.881706237792968, + 52.341789445960536 + ], + [ + 4.878444671630859, + 52.341789445960536 + ], + [ + 4.87818717956543, + 52.34435884510934 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Park de Schinkeleilanden", + "type": "Park", + "description": "This park was built between 2005 and 2010 and is popular for the neighborhoods surrounding the Schinkel waterway. It's allowed to BBQ here, and it's a popular spot for running and hiking." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.851171970367432, + 52.34405734171741 + ], + [ + 4.851021766662597, + 52.34514536601911 + ], + [ + 4.851686954498291, + 52.34628579648493 + ], + [ + 4.851021766662597, + 52.3465610683968 + ], + [ + 4.848833084106445, + 52.342785761313266 + ], + [ + 4.849659204483032, + 52.340747223639156 + ], + [ + 4.852405786514282, + 52.34110774357341 + ], + [ + 4.852041006088257, + 52.34196642466951 + ], + [ + 4.852041006088257, + 52.341979534175316 + ], + [ + 4.851665496826172, + 52.34280870252078 + ], + [ + 4.851171970367432, + 52.34405734171741 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Schiphol", + "type": "area", + "description": "Schiphol is the main international airport of the Netherlands. Schiphol Airport is an important European airport, ranking as Europe's fifth busiest and the world's fourteenth busiest by total passenger traffic in 2015. It also ranks as the world's fifth busiest by international passenger traffic. The entire airport is below sea level; the lowest point sits at 3.4 m (11 ft) below sea level." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.729099273681641, + 52.28811257899827 + ], + [ + 4.734764099121094, + 52.28559241729168 + ], + [ + 4.762744903564453, + 52.292522517043615 + ], + [ + 4.776134490966797, + 52.284857343123655 + ], + [ + 4.7907257080078125, + 52.293992398835414 + ], + [ + 4.793128967285156, + 52.30081621106509 + ], + [ + 4.803943634033203, + 52.30564473517634 + ], + [ + 4.810981750488281, + 52.311942018805624 + ], + [ + 4.796905517578125, + 52.319707434957024 + ], + [ + 4.788494110107422, + 52.320966563244205 + ], + [ + 4.779567718505859, + 52.32442898129939 + ], + [ + 4.77081298828125, + 52.3191827875965 + ], + [ + 4.756736755371094, + 52.31886799619451 + ], + [ + 4.750041961669922, + 52.310367781878 + ], + [ + 4.7454071044921875, + 52.30281066528705 + ], + [ + 4.7426605224609375, + 52.29798183210937 + ], + [ + 4.729099273681641, + 52.28811257899827 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Noorderpark", + "type": "park", + "description": "The Noorderpark is a park just 5 minutes north of the ferry that crosses the IJ canal behind Amsterdam Central Station. It came to exist in 2014 after combining Florapark and Volewijkspark." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.921703338623047, + 52.39046464493288 + ], + [ + 4.921939373016357, + 52.389652739777624 + ], + [ + 4.92436408996582, + 52.39068726147955 + ], + [ + 4.924213886260986, + 52.390922971893374 + ], + [ + 4.92460012435913, + 52.39105392157937 + ], + [ + 4.923999309539795, + 52.39326691251008 + ], + [ + 4.924793243408203, + 52.39486438729677 + ], + [ + 4.922282695770264, + 52.39698553494043 + ], + [ + 4.919922351837158, + 52.39847813327716 + ], + [ + 4.917948246002197, + 52.397705654476155 + ], + [ + 4.918398857116699, + 52.39618684316538 + ], + [ + 4.917948246002197, + 52.39527029380819 + ], + [ + 4.917197227478027, + 52.39200984251752 + ], + [ + 4.9161458015441895, + 52.39068726147955 + ], + [ + 4.918420314788818, + 52.389901551009025 + ], + [ + 4.920244216918945, + 52.39115868104846 + ], + [ + 4.921402931213379, + 52.39157771643836 + ], + [ + 4.922153949737548, + 52.39121106068977 + ], + [ + 4.921703338623047, + 52.39046464493288 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Vliegenbos", + "type": "park", + "description": "The Vliegenbos is the oldest city forest in Amsterdam. Here you've got plenty of space to run or cycle through a dense forest. It also hosts a camping ground, and is an amazingly well located starting point for excursions to the fishing villages along the IJsselmeer. " + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.925222396850586, + 52.389403927143704 + ], + [ + 4.925136566162109, + 52.39003250372539 + ], + [ + 4.926724433898926, + 52.39105392157937 + ], + [ + 4.933032989501953, + 52.391525337232174 + ], + [ + 4.93311882019043, + 52.390739641680284 + ], + [ + 4.938998222351074, + 52.38969202585476 + ], + [ + 4.9376678466796875, + 52.38686333892666 + ], + [ + 4.927024841308593, + 52.38906344442449 + ], + [ + 4.926466941833496, + 52.38948249970591 + ], + [ + 4.9253082275390625, + 52.38945630886739 + ], + [ + 4.925222396850586, + 52.389403927143704 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Flevopark", + "type": "park", + "description": "Flevopark is the jewel in the East of Amsterdam. Its offerings include an outdoor swimming pool, several lakes, restaurants. It's awesome for a bbq in summer or a foggy walk or run on a winter morning." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.948225021362305, + 52.36493486877479 + ], + [ + 4.9527740478515625, + 52.36517071668903 + ], + [ + 4.954404830932617, + 52.36517071668903 + ], + [ + 4.955005645751953, + 52.36459419734253 + ], + [ + 4.952559471130371, + 52.36215700971062 + ], + [ + 4.952859878540038, + 52.35953622784585 + ], + [ + 4.952731132507324, + 52.35809473156134 + ], + [ + 4.944963455200195, + 52.35859270832139 + ], + [ + 4.946165084838867, + 52.362314251679365 + ], + [ + 4.947195053100586, + 52.362602527168704 + ], + [ + 4.947667121887207, + 52.36417490581972 + ], + [ + 4.948225021362305, + 52.36493486877479 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amsterdam Centraal", + "type": "station", + "description": "Amsterdam's Central Station." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.896576404571533, + 52.37985631995486 + ], + [ + 4.89715576171875, + 52.38066840529253 + ], + [ + 4.90389347076416, + 52.37820590695898 + ], + [ + 4.902949333190918, + 52.37738067732881 + ], + [ + 4.896576404571533, + 52.37985631995486 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amsterdam Amstel", + "type": "station", + "description": "Amsterdam Amstel is a trainstation in the South East, close to the river Amstel." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.916896820068359, + 52.3468101224592 + ], + [ + 4.917690753936768, + 52.34704606711881 + ], + [ + 4.918248653411864, + 52.34604984776767 + ], + [ + 4.9173903465271, + 52.34584011451739 + ], + [ + 4.916896820068359, + 52.3468101224592 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Ouderkerk", + "type": "poi", + "description": "Ouderkerk aan de Amstel is a picturesque village in the Dutch province of North Holland. It lies about 9 km south of Amsterdam. The town is a popular destination for Amsterdammers on the weekends. The town is the location of the Beth Haim of Ouderkerk aan de Amstel, the oldest Jewish cemetery in the Netherlands." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.922518730163574, + 52.29236502681571 + ], + [ + 4.922819137573242, + 52.28777131549237 + ], + [ + 4.90788459777832, + 52.29034385252062 + ], + [ + 4.892692565917969, + 52.29456983905114 + ], + [ + 4.898228645324707, + 52.29824428222637 + ], + [ + 4.902563095092773, + 52.299267822821434 + ], + [ + 4.908742904663086, + 52.29879542240944 + ], + [ + 4.916167259216309, + 52.30149853446092 + ], + [ + 4.920544624328613, + 52.29666955819423 + ], + [ + 4.922518730163574, + 52.29236502681571 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "NDSM terrein", + "type": "poi", + "description": "The former NDSM Amsterdam ship wharf is a stunning hangout. Just 10 minutes by free ferry and a large area is there to explore. Restaurants, bars, terraces, skatepark, new and old architecture, all with the amazing view on the IJ-waters. Many of the old buildings that were in use for the making of large ships are still there, housing creative enterprises." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.890182018280029, + 52.401711923144106 + ], + [ + 4.894495010375977, + 52.40307344797437 + ], + [ + 4.899129867553711, + 52.400939500955296 + ], + [ + 4.896554946899414, + 52.39881854337136 + ], + [ + 4.8909544944763175, + 52.39813772055684 + ], + [ + 4.891490936279297, + 52.400847856747404 + ], + [ + 4.890182018280029, + 52.401711923144106 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amsterdam Zuid", + "type": "station", + "description": "Station Amsterdam Zuid" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.8720502853393555, + 52.33950832364112 + ], + [ + 4.874711036682129, + 52.33969186657182 + ], + [ + 4.8749041557312, + 52.338459492279576 + ], + [ + 4.872071743011475, + 52.33835460777523 + ], + [ + 4.8720502853393555, + 52.33950832364112 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Het Twiske", + "type": "park", + "description": "Het Twiske recreational area lies to the north of Amsterdam between Zaanstad and Purmerend. It’s the ideal place for a day out on your bicycle, as Amsterdam’s bike paths connect directly to the paths in Het Twiske." + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.888744354248047, + 52.43555429631541 + ], + [ + 4.900503158569336, + 52.43445541622349 + ], + [ + 4.910116195678711, + 52.43586825702301 + ], + [ + 4.910888671875, + 52.442199320554714 + ], + [ + 4.907197952270508, + 52.44852947442261 + ], + [ + 4.90565299987793, + 52.449941863962756 + ], + [ + 4.905910491943359, + 52.45135420821245 + ], + [ + 4.903764724731445, + 52.4549633266463 + ], + [ + 4.903507232666016, + 52.45846754991504 + ], + [ + 4.904794692993164, + 52.461866903001194 + ], + [ + 4.906854629516602, + 52.46489995032684 + ], + [ + 4.906940460205078, + 52.465736616263186 + ], + [ + 4.9031639099121085, + 52.4673576112622 + ], + [ + 4.896640777587891, + 52.468560246396606 + ], + [ + 4.895782470703125, + 52.46793278868704 + ], + [ + 4.892778396606445, + 52.465422868400594 + ], + [ + 4.890289306640625, + 52.46416785458775 + ], + [ + 4.882049560546875, + 52.46191919869101 + ], + [ + 4.876041412353516, + 52.45982732264483 + ], + [ + 4.87492561340332, + 52.45825835038316 + ], + [ + 4.873895645141601, + 52.45648011423114 + ], + [ + 4.873037338256836, + 52.454911022694276 + ], + [ + 4.873552322387695, + 52.452714200611055 + ], + [ + 4.874839782714844, + 52.44805866784458 + ], + [ + 4.879388809204102, + 52.44277482667677 + ], + [ + 4.883165359497069, + 52.43926935464697 + ], + [ + 4.887542724609374, + 52.43597291009513 + ], + [ + 4.888744354248047, + 52.43555429631541 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Diemerpark", + "type": "park" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.974660873413086, + 52.35694150067703 + ], + [ + 4.980497360229492, + 52.357989893633615 + ], + [ + 4.985218048095703, + 52.35827819733633 + ], + [ + 4.986248016357422, + 52.35720360124792 + ], + [ + 4.985218048095703, + 52.355971715048284 + ], + [ + 4.985218048095703, + 52.3552640202125 + ], + [ + 4.986376762390137, + 52.3545563140442 + ], + [ + 4.987921714782714, + 52.353901020450564 + ], + [ + 4.988865852355957, + 52.353901020450564 + ], + [ + 4.989681243896484, + 52.353219504806525 + ], + [ + 4.991183280944824, + 52.352642829515084 + ], + [ + 4.992728233337402, + 52.35169916280845 + ], + [ + 4.994831085205078, + 52.34996905485244 + ], + [ + 4.995818138122559, + 52.34991662628147 + ], + [ + 4.997320175170898, + 52.348763181988105 + ], + [ + 4.997320175170898, + 52.348081587122245 + ], + [ + 4.99852180480957, + 52.34658728467996 + ], + [ + 4.999551773071289, + 52.34535510256526 + ], + [ + 4.999337196350098, + 52.345197800248926 + ], + [ + 4.976506233215332, + 52.35573581802885 + ], + [ + 4.974660873413086, + 52.35694150067703 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Amstelfeld", + "type": "poi" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.897080659866332, + 52.36253045847271 + ], + [ + 4.8978424072265625, + 52.36269425079362 + ], + [ + 4.89815354347229, + 52.362137354425165 + ], + [ + 4.896329641342163, + 52.36185562770631 + ], + [ + 4.896275997161865, + 52.36240597590272 + ], + [ + 4.897080659866332, + 52.36253045847271 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Albert Cuyp Markt", + "type": "poi" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.890514612197876, + 52.35491672137934 + ], + [ + 4.894967079162598, + 52.35580134510498 + ], + [ + 4.896436929702759, + 52.356168294935955 + ], + [ + 4.899580478668213, + 52.3570725511568 + ], + [ + 4.899430274963379, + 52.35731499351983 + ], + [ + 4.897252321243286, + 52.356587662440496 + ], + [ + 4.895503520965576, + 52.356076557763856 + ], + [ + 4.893561601638794, + 52.355683396297984 + ], + [ + 4.8904502391815186, + 52.35510020034824 + ], + [ + 4.890514612197876, + 52.35491672137934 + ] + ] + ] + } + }, + { + "type": "Feature", + "properties": { + "stroke": "#555555", + "stroke-width": 2, + "stroke-opacity": 1, + "fill": "#555555", + "fill-opacity": 0.5, + "name": "Noordermarkt", + "type": "poi" + }, + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + 4.885987043380737, + 52.37978100483205 + ], + [ + 4.886265993118286, + 52.37907041669766 + ], + [ + 4.886485934257507, + 52.37900819875896 + ], + [ + 4.886732697486877, + 52.37907041669766 + ], + [ + 4.887698292732239, + 52.38007244089837 + ], + [ + 4.885987043380737, + 52.37978100483205 + ] + ] + ] + } + } + ] +} diff --git a/platform/macos/app/Base.lproj/MapDocument.xib b/platform/macos/app/Base.lproj/MapDocument.xib index 55d82d21d0..93fe5cbeec 100644 --- a/platform/macos/app/Base.lproj/MapDocument.xib +++ b/platform/macos/app/Base.lproj/MapDocument.xib @@ -1,5 +1,5 @@ -<?xml version="1.0" encoding="UTF-8" standalone="no"?> -<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="10117" systemVersion="15F34" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES"> +<?xml version="1.0" encoding="UTF-8"?> +<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="10117" systemVersion="16A254g" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES"> <dependencies> <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="10117"/> </dependencies> @@ -17,7 +17,7 @@ <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES" fullSizeContentView="YES"/> <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/> <rect key="contentRect" x="388" y="211" width="512" height="480"/> - <rect key="screenRect" x="0.0" y="0.0" width="1280" height="777"/> + <rect key="screenRect" x="0.0" y="0.0" width="1920" height="1058"/> <view key="contentView" id="TuG-C5-zLS"> <rect key="frame" x="0.0" y="0.0" width="512" height="480"/> <autoresizingMask key="autoresizingMask"/> @@ -111,10 +111,10 @@ </window> <menu title="Map View" id="XbX-6a-Mgy"> <items> - <menuItem title="Drop Pin" id="qZJ-mM-bLj"> + <menuItem title="Drop Pin" id="KiK-wh-YwN"> <modifierMask key="keyEquivalentModifierMask"/> <connections> - <action selector="dropPin:" target="-1" id="hxx-eC-kqU"/> + <action selector="dropPin:" target="-1" id="ZH6-Tj-IJT"/> </connections> </menuItem> <menuItem title="Remove Pin" id="Zhx-30-VmE"> @@ -129,6 +129,12 @@ <action selector="selectFeatures:" target="-1" id="ikt-CZ-yZT"/> </connections> </menuItem> + <menuItem title="Runtime styling" id="qZJ-mM-bLj"> + <modifierMask key="keyEquivalentModifierMask"/> + <connections> + <action selector="runtimeStyling:" target="-1" id="gN9-lw-fG8"/> + </connections> + </menuItem> </items> <connections> <outlet property="delegate" destination="-2" id="oHe-ZP-lyc"/> diff --git a/platform/macos/app/MapDocument.m b/platform/macos/app/MapDocument.m index 81fd85e156..24f172b41b 100644 --- a/platform/macos/app/MapDocument.m +++ b/platform/macos/app/MapDocument.m @@ -484,6 +484,26 @@ NS_ARRAY_OF(id <MGLAnnotation>) *MBXFlattenedShapes(NS_ARRAY_OF(id <MGLAnnotatio } } +- (IBAction)runtimeStyling:(id)sender { + MGLFillStyleLayer *fillStyleLayer = (MGLFillStyleLayer *)[self.mapView.style layerWithIdentifier:@"water"]; + + MGLStyleAttributeFunction *colorFunction = [[MGLStyleAttributeFunction alloc] init]; + colorFunction.stops = @{ + @0.0: [NSColor redColor], + @10.0: [NSColor yellowColor], + @20.0: [NSColor blackColor], + }; + fillStyleLayer.fillColor = colorFunction; + + NSURL *geoJSONURL = [NSURL URLWithString:@"https://dl.dropboxusercontent.com/u/5285447/amsterdam.geojson"]; + MGLGeoJSONSource *source = [[MGLGeoJSONSource alloc] initWithSourceIdentifier:@"ams" URL:geoJSONURL]; + [self.mapView.style addSource:source]; + + MGLFillStyleLayer *fillLayer = [[MGLFillStyleLayer alloc] initWithLayerIdentifier:@"test" sourceIdentifier:@"ams"]; + fillLayer.fillColor = [NSColor purpleColor]; + [self.mapView.style addLayer:fillLayer]; +} + - (IBAction)dropPin:(NSMenuItem *)sender { [self dropPinAtPoint:_mouseLocationForMapViewContextMenu]; } @@ -579,6 +599,9 @@ NS_ARRAY_OF(id <MGLAnnotation>) *MBXFlattenedShapes(NS_ARRAY_OF(id <MGLAnnotatio if (menuItem.action == @selector(reload:)) { return YES; } + if (menuItem.action == @selector(runtimeStyling:)) { + return YES; + } if (menuItem.action == @selector(dropPin:)) { id <MGLAnnotation> annotationUnderCursor = [self.mapView annotationAtPoint:_mouseLocationForMapViewContextMenu]; menuItem.hidden = annotationUnderCursor != nil; diff --git a/platform/macos/config.cmake b/platform/macos/config.cmake index 30e2f81523..6e39c78d35 100644 --- a/platform/macos/config.cmake +++ b/platform/macos/config.cmake @@ -38,6 +38,8 @@ macro(mbgl_platform_core) PRIVATE platform/default/headless_view.cpp ) + target_add_mason_package(mbgl-core PUBLIC geojson) + target_compile_options(mbgl-core PRIVATE -fobjc-arc ) diff --git a/platform/macos/macos.xcodeproj/project.pbxproj b/platform/macos/macos.xcodeproj/project.pbxproj index 25af9015ac..a0b217662a 100644 --- a/platform/macos/macos.xcodeproj/project.pbxproj +++ b/platform/macos/macos.xcodeproj/project.pbxproj @@ -7,12 +7,39 @@ objects = { /* Begin PBXBuildFile section */ + 352742781D4C220900A1ECE6 /* MGLStyleAttributeValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 352742771D4C220900A1ECE6 /* MGLStyleAttributeValue.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3527427C1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 3527427A1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3527427D1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = 3527427B1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.m */; }; + 352742811D4C243B00A1ECE6 /* MGLSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 3527427F1D4C243B00A1ECE6 /* MGLSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 352742821D4C243B00A1ECE6 /* MGLSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 352742801D4C243B00A1ECE6 /* MGLSource.mm */; }; + 352742851D4C244700A1ECE6 /* MGLRasterSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 352742831D4C244700A1ECE6 /* MGLRasterSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 352742861D4C244700A1ECE6 /* MGLRasterSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 352742841D4C244700A1ECE6 /* MGLRasterSource.mm */; }; + 352742891D4C245800A1ECE6 /* MGLGeoJSONSource.h in Headers */ = {isa = PBXBuildFile; fileRef = 352742871D4C245800A1ECE6 /* MGLGeoJSONSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3527428A1D4C245800A1ECE6 /* MGLGeoJSONSource.mm in Sources */ = {isa = PBXBuildFile; fileRef = 352742881D4C245800A1ECE6 /* MGLGeoJSONSource.mm */; }; + 3527428D1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 3527428B1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3527428E1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3527428C1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.mm */; }; + 3527429F1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3527429C1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction_Private.hpp */; }; + 352742A01D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 3527429D1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 352742A11D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3527429E1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.mm */; }; + 3537CA741D3F93A600380318 /* MGLStyle_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3537CA731D3F93A600380318 /* MGLStyle_Private.hpp */; }; + 3538AA231D542685008EC33D /* MGLBaseStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 3538AA211D542685008EC33D /* MGLBaseStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 3538AA241D542685008EC33D /* MGLBaseStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3538AA221D542685008EC33D /* MGLBaseStyleLayer.mm */; }; + 355BA4ED1D41633E00CCC6D5 /* NSColor+MGLAdditions.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 355BA4EB1D41633E00CCC6D5 /* NSColor+MGLAdditions.hpp */; settings = {ATTRIBUTES = (Public, ); }; }; + 355BA4EE1D41633E00CCC6D5 /* NSColor+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 355BA4EC1D41633E00CCC6D5 /* NSColor+MGLAdditions.mm */; }; + 35602BFA1D3EA99F0050646F /* MGLFillStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35602BF81D3EA99F0050646F /* MGLFillStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35602BFB1D3EA99F0050646F /* MGLFillStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35602BF91D3EA99F0050646F /* MGLFillStyleLayer.mm */; }; + 35602BFF1D3EA9B40050646F /* MGLStyleLayer_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 35602BFC1D3EA9B40050646F /* MGLStyleLayer_Private.hpp */; }; + 35602C001D3EA9B40050646F /* MGLStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 35602BFD1D3EA9B40050646F /* MGLStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 35602C011D3EA9B40050646F /* MGLStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 35602BFE1D3EA9B40050646F /* MGLStyleLayer.mm */; }; + 3593E52A1D52A628006D9365 /* MGLStyleAttribute.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E5281D52A628006D9365 /* MGLStyleAttribute.hpp */; }; + 3593E52B1D52A628006D9365 /* MGLStyleAttribute.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3593E5291D52A628006D9365 /* MGLStyleAttribute.mm */; }; + 3593E52D1D52A680006D9365 /* NSColor+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3593E52C1D52A680006D9365 /* NSColor+MGLStyleAttributeAdditions_Private.hpp */; }; 52BECB0A1CC5A26F009CD791 /* SystemConfiguration.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 52BECB091CC5A26F009CD791 /* SystemConfiguration.framework */; }; 5548BE781D09E718005DDE81 /* libmbgl-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = DAE6C3451CC31D1200DB3429 /* libmbgl-core.a */; }; - 5548BE7D1D0ACCD6005DDE81 /* libmbgl-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = DAE6C3451CC31D1200DB3429 /* libmbgl-core.a */; }; 558F18221D0B13B100123F46 /* libmbgl-loop.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 558F18211D0B13B000123F46 /* libmbgl-loop.a */; }; 55D9B4B11D005D3900C1CCE2 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 55D9B4B01D005D3900C1CCE2 /* libz.tbd */; }; DA0CD58E1CF56F5800A5F5A5 /* MGLFeatureTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA0CD58D1CF56F5800A5F5A5 /* MGLFeatureTests.mm */; }; + DA2DBBCB1D51E30A00D38FF9 /* MGLStyleLayerTests.xib in Resources */ = {isa = PBXBuildFile; fileRef = DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */; }; DA35A2A41CC9EB1A00E826B2 /* MGLCoordinateFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = DA35A2A31CC9EB1A00E826B2 /* MGLCoordinateFormatter.h */; settings = {ATTRIBUTES = (Public, ); }; }; DA35A2A61CC9EB2700E826B2 /* MGLCoordinateFormatter.m in Sources */ = {isa = PBXBuildFile; fileRef = DA35A2A51CC9EB2700E826B2 /* MGLCoordinateFormatter.m */; }; DA35A2A81CC9F41600E826B2 /* MGLCoordinateFormatterTests.m in Sources */ = {isa = PBXBuildFile; fileRef = DA35A2A71CC9F41600E826B2 /* MGLCoordinateFormatterTests.m */; }; @@ -35,6 +62,31 @@ DA8933AE1CCD290700E68420 /* Localizable.strings in Resources */ = {isa = PBXBuildFile; fileRef = DA8933AB1CCD290700E68420 /* Localizable.strings */; }; DA8933B51CCD2C2500E68420 /* Foundation.strings in Resources */ = {isa = PBXBuildFile; fileRef = DA8933B31CCD2C2500E68420 /* Foundation.strings */; }; DA8933B81CCD2C2D00E68420 /* Foundation.stringsdict in Resources */ = {isa = PBXBuildFile; fileRef = DA8933B61CCD2C2D00E68420 /* Foundation.stringsdict */; }; + DA8F25871D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25851D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25881D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25861D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm */; }; + DA8F258B1D51CA540010E6B5 /* MGLLineStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25891D51CA540010E6B5 /* MGLLineStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F258C1D51CA540010E6B5 /* MGLLineStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F258A1D51CA540010E6B5 /* MGLLineStyleLayer.mm */; }; + DA8F258F1D51CA600010E6B5 /* MGLRasterStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F258D1D51CA600010E6B5 /* MGLRasterStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25901D51CA600010E6B5 /* MGLRasterStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F258E1D51CA600010E6B5 /* MGLRasterStyleLayer.mm */; }; + DA8F25931D51CA750010E6B5 /* MGLSymbolStyleLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25911D51CA750010E6B5 /* MGLSymbolStyleLayer.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25941D51CA750010E6B5 /* MGLSymbolStyleLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25921D51CA750010E6B5 /* MGLSymbolStyleLayer.mm */; }; + DA8F25971D51CAC70010E6B5 /* MGLVectorSource.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25951D51CAC70010E6B5 /* MGLVectorSource.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25981D51CAC70010E6B5 /* MGLVectorSource.m in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25961D51CAC70010E6B5 /* MGLVectorSource.m */; }; + DA8F259A1D51CAD00010E6B5 /* MGLSource_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25991D51CAD00010E6B5 /* MGLSource_Private.hpp */; }; + DA8F259C1D51CB000010E6B5 /* MGLStyleAttributeValue_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F259B1D51CB000010E6B5 /* MGLStyleAttributeValue_Private.hpp */; }; + DA8F25A91D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F259D1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25AA1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F259E1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.mm */; }; + DA8F25AB1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F259F1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */; }; + DA8F25AC1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A01D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25AD1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25A11D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.mm */; }; + DA8F25AE1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A21D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */; }; + DA8F25AF1D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A31D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25B01D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25A41D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.mm */; }; + DA8F25B11D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A51D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions_Private.hpp */; }; + DA8F25B21D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A61D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h */; settings = {ATTRIBUTES = (Public, ); }; }; + DA8F25B31D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = DA8F25A71D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm */; }; + DA8F25B41D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DA8F25A81D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */; }; + DAB6924A1CC75A31005AAB54 /* libmbgl-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = DAE6C3451CC31D1200DB3429 /* libmbgl-core.a */; }; DAC2ABC51CC6D343006D18C4 /* MGLAnnotationImage_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = DAC2ABC41CC6D343006D18C4 /* MGLAnnotationImage_Private.h */; }; DACC22141CF3D3E200D220D9 /* MGLFeature.h in Headers */ = {isa = PBXBuildFile; fileRef = DACC22121CF3D3E200D220D9 /* MGLFeature.h */; settings = {ATTRIBUTES = (Public, ); }; }; DACC22151CF3D3E200D220D9 /* MGLFeature.mm in Sources */ = {isa = PBXBuildFile; fileRef = DACC22131CF3D3E200D220D9 /* MGLFeature.mm */; }; @@ -100,9 +152,9 @@ DAE6C3B31CC31EF300DB3429 /* MGLAttributionButton.m in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3A91CC31EF300DB3429 /* MGLAttributionButton.m */; }; DAE6C3B41CC31EF300DB3429 /* MGLCompassCell.h in Headers */ = {isa = PBXBuildFile; fileRef = DAE6C3AA1CC31EF300DB3429 /* MGLCompassCell.h */; }; DAE6C3B51CC31EF300DB3429 /* MGLCompassCell.m in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3AB1CC31EF300DB3429 /* MGLCompassCell.m */; }; - DAE6C3B61CC31EF300DB3429 /* MGLMapView_Private.h in Headers */ = {isa = PBXBuildFile; fileRef = DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.h */; }; + DAE6C3B61CC31EF300DB3429 /* MGLMapView_Private.hpp in Headers */ = {isa = PBXBuildFile; fileRef = DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.hpp */; }; DAE6C3B71CC31EF300DB3429 /* MGLMapView.mm in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3AD1CC31EF300DB3429 /* MGLMapView.mm */; }; - DAE6C3B81CC31EF300DB3429 /* MGLMapView+IBAdditions.m in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.m */; }; + DAE6C3B81CC31EF300DB3429 /* MGLMapView+IBAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.mm */; }; DAE6C3B91CC31EF300DB3429 /* MGLOpenGLLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = DAE6C3AF1CC31EF300DB3429 /* MGLOpenGLLayer.h */; }; DAE6C3BA1CC31EF300DB3429 /* MGLOpenGLLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = DAE6C3B01CC31EF300DB3429 /* MGLOpenGLLayer.mm */; }; DAE6C3BE1CC31F2E00DB3429 /* default_marker.pdf in Resources */ = {isa = PBXBuildFile; fileRef = DAE6C3BB1CC31F2E00DB3429 /* default_marker.pdf */; }; @@ -148,6 +200,33 @@ /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ + 352742771D4C220900A1ECE6 /* MGLStyleAttributeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleAttributeValue.h; sourceTree = "<group>"; }; + 3527427A1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSColor+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + 3527427B1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSColor+MGLStyleAttributeAdditions.m"; sourceTree = "<group>"; }; + 3527427F1D4C243B00A1ECE6 /* MGLSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLSource.h; sourceTree = "<group>"; }; + 352742801D4C243B00A1ECE6 /* MGLSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLSource.mm; sourceTree = "<group>"; }; + 352742831D4C244700A1ECE6 /* MGLRasterSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLRasterSource.h; sourceTree = "<group>"; }; + 352742841D4C244700A1ECE6 /* MGLRasterSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterSource.mm; sourceTree = "<group>"; }; + 352742871D4C245800A1ECE6 /* MGLGeoJSONSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLGeoJSONSource.h; sourceTree = "<group>"; }; + 352742881D4C245800A1ECE6 /* MGLGeoJSONSource.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLGeoJSONSource.mm; sourceTree = "<group>"; }; + 3527428B1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLCircleStyleLayer.h; sourceTree = "<group>"; }; + 3527428C1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLCircleStyleLayer.mm; sourceTree = "<group>"; }; + 3527429C1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttributeFunction_Private.hpp; sourceTree = "<group>"; }; + 3527429D1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleAttributeFunction.h; sourceTree = "<group>"; }; + 3527429E1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleAttributeFunction.mm; sourceTree = "<group>"; }; + 3537CA731D3F93A600380318 /* MGLStyle_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyle_Private.hpp; sourceTree = "<group>"; }; + 3538AA211D542685008EC33D /* MGLBaseStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLBaseStyleLayer.h; sourceTree = "<group>"; }; + 3538AA221D542685008EC33D /* MGLBaseStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBaseStyleLayer.mm; sourceTree = "<group>"; }; + 355BA4EB1D41633E00CCC6D5 /* NSColor+MGLAdditions.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSColor+MGLAdditions.hpp"; sourceTree = "<group>"; }; + 355BA4EC1D41633E00CCC6D5 /* NSColor+MGLAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSColor+MGLAdditions.mm"; sourceTree = "<group>"; }; + 35602BF81D3EA99F0050646F /* MGLFillStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLFillStyleLayer.h; sourceTree = "<group>"; }; + 35602BF91D3EA99F0050646F /* MGLFillStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLFillStyleLayer.mm; sourceTree = "<group>"; }; + 35602BFC1D3EA9B40050646F /* MGLStyleLayer_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleLayer_Private.hpp; sourceTree = "<group>"; }; + 35602BFD1D3EA9B40050646F /* MGLStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLStyleLayer.h; sourceTree = "<group>"; }; + 35602BFE1D3EA9B40050646F /* MGLStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleLayer.mm; sourceTree = "<group>"; }; + 3593E5281D52A628006D9365 /* MGLStyleAttribute.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttribute.hpp; sourceTree = "<group>"; }; + 3593E5291D52A628006D9365 /* MGLStyleAttribute.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLStyleAttribute.mm; sourceTree = "<group>"; }; + 3593E52C1D52A680006D9365 /* NSColor+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSColor+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; 52BECB091CC5A26F009CD791 /* SystemConfiguration.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SystemConfiguration.framework; path = System/Library/Frameworks/SystemConfiguration.framework; sourceTree = SDKROOT; }; 5548BE791D0ACBB2005DDE81 /* libmbgl-loop-darwin.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libmbgl-loop-darwin.a"; path = "cmake/Debug/libmbgl-loop-darwin.a"; sourceTree = "<group>"; }; 5548BE7B1D0ACBBD005DDE81 /* libmbgl-loop-darwin.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libmbgl-loop-darwin.a"; path = "cmake/Debug/libmbgl-loop-darwin.a"; sourceTree = "<group>"; }; @@ -155,6 +234,9 @@ 55D9B4B01D005D3900C1CCE2 /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; }; 55FE0E8D1D100A0900FD240B /* config.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = config.xcconfig; path = ../../build/macos/config.xcconfig; sourceTree = "<group>"; }; DA0CD58D1CF56F5800A5F5A5 /* MGLFeatureTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = MGLFeatureTests.mm; path = ../../darwin/test/MGLFeatureTests.mm; sourceTree = "<group>"; }; + DA2DBBC71D51E26600D38FF9 /* MGLStyleLayerTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLStyleLayerTests.h; path = ../darwin/test/MGLStyleLayerTests.h; sourceTree = SOURCE_ROOT; }; + DA2DBBC81D51E26600D38FF9 /* MGLStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLStyleLayerTests.m; path = ../darwin/test/MGLStyleLayerTests.m; sourceTree = SOURCE_ROOT; }; + DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.xib; path = MGLStyleLayerTests.xib; sourceTree = "<group>"; }; DA35A2A31CC9EB1A00E826B2 /* MGLCoordinateFormatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLCoordinateFormatter.h; sourceTree = "<group>"; }; DA35A2A51CC9EB2700E826B2 /* MGLCoordinateFormatter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLCoordinateFormatter.m; sourceTree = "<group>"; }; DA35A2A71CC9F41600E826B2 /* MGLCoordinateFormatterTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCoordinateFormatterTests.m; path = ../../darwin/test/MGLCoordinateFormatterTests.m; sourceTree = "<group>"; }; @@ -181,6 +263,41 @@ DA8933AC1CCD290700E68420 /* Base */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = Base; path = Base.lproj/Localizable.strings; sourceTree = "<group>"; }; DA8933B41CCD2C2500E68420 /* Base */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = Base; path = Base.lproj/Foundation.strings; sourceTree = "<group>"; }; DA8933B71CCD2C2D00E68420 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.stringsdict; name = en; path = en.lproj/Foundation.stringsdict; sourceTree = "<group>"; }; + DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLFillStyleLayerTests.m; path = ../../darwin/test/MGLFillStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRasterStyleLayerTests.m; path = ../../darwin/test/MGLRasterStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLSymbolStyleLayerTests.m; path = ../../darwin/test/MGLSymbolStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLLineStyleLayerTests.m; path = ../../darwin/test/MGLLineStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLCircleStyleLayerTests.m; path = ../../darwin/test/MGLCircleStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLBackgroundStyleLayerTests.m; path = ../../darwin/test/MGLBackgroundStyleLayerTests.m; sourceTree = "<group>"; }; + DA8F257A1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MGLRuntimeStylingHelper.h; path = ../../darwin/test/MGLRuntimeStylingHelper.h; sourceTree = "<group>"; }; + DA8F257B1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MGLRuntimeStylingHelper.m; path = ../../darwin/test/MGLRuntimeStylingHelper.m; sourceTree = "<group>"; }; + DA8F25851D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLBackgroundStyleLayer.h; sourceTree = "<group>"; }; + DA8F25861D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLBackgroundStyleLayer.mm; sourceTree = "<group>"; }; + DA8F25891D51CA540010E6B5 /* MGLLineStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLLineStyleLayer.h; sourceTree = "<group>"; }; + DA8F258A1D51CA540010E6B5 /* MGLLineStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLLineStyleLayer.mm; sourceTree = "<group>"; }; + DA8F258D1D51CA600010E6B5 /* MGLRasterStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLRasterStyleLayer.h; sourceTree = "<group>"; }; + DA8F258E1D51CA600010E6B5 /* MGLRasterStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLRasterStyleLayer.mm; sourceTree = "<group>"; }; + DA8F25911D51CA750010E6B5 /* MGLSymbolStyleLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLSymbolStyleLayer.h; sourceTree = "<group>"; }; + DA8F25921D51CA750010E6B5 /* MGLSymbolStyleLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLSymbolStyleLayer.mm; sourceTree = "<group>"; }; + DA8F25951D51CAC70010E6B5 /* MGLVectorSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLVectorSource.h; sourceTree = "<group>"; }; + DA8F25961D51CAC70010E6B5 /* MGLVectorSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLVectorSource.m; sourceTree = "<group>"; }; + DA8F25991D51CAD00010E6B5 /* MGLSource_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLSource_Private.hpp; sourceTree = "<group>"; }; + DA8F259B1D51CB000010E6B5 /* MGLStyleAttributeValue_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLStyleAttributeValue_Private.hpp; sourceTree = "<group>"; }; + DA8F259D1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSNumber+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + DA8F259E1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSNumber+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + DA8F259F1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSNumber+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + DA8F25A01D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSArray+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + DA8F25A11D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSArray+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + DA8F25A21D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSArray+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + DA8F25A31D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + DA8F25A41D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSString+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + DA8F25A51D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSString+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + DA8F25A61D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSValue+MGLStyleAttributeAdditions.h"; sourceTree = "<group>"; }; + DA8F25A71D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSValue+MGLStyleAttributeAdditions.mm"; sourceTree = "<group>"; }; + DA8F25A81D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "NSValue+MGLStyleAttributeAdditions_Private.hpp"; sourceTree = "<group>"; }; + DA8F25B51D51D2240010E6B5 /* MGLRuntimeStylingTests.m.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLRuntimeStylingTests.m.ejs; sourceTree = "<group>"; }; + DA8F25B61D51D2240010E6B5 /* MGLStyleLayer.h.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.h.ejs; sourceTree = "<group>"; }; + DA8F25B71D51D2240010E6B5 /* MGLStyleLayer.mm.ejs */ = {isa = PBXFileReference; lastKnownFileType = text; path = MGLStyleLayer.mm.ejs; sourceTree = "<group>"; }; DAC2ABC41CC6D343006D18C4 /* MGLAnnotationImage_Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLAnnotationImage_Private.h; sourceTree = "<group>"; }; DACC22121CF3D3E200D220D9 /* MGLFeature.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLFeature.h; sourceTree = "<group>"; }; DACC22131CF3D3E200D220D9 /* MGLFeature.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLFeature.mm; sourceTree = "<group>"; }; @@ -253,9 +370,9 @@ DAE6C3A91CC31EF300DB3429 /* MGLAttributionButton.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLAttributionButton.m; sourceTree = "<group>"; }; DAE6C3AA1CC31EF300DB3429 /* MGLCompassCell.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLCompassCell.h; sourceTree = "<group>"; }; DAE6C3AB1CC31EF300DB3429 /* MGLCompassCell.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = MGLCompassCell.m; sourceTree = "<group>"; }; - DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLMapView_Private.h; sourceTree = "<group>"; }; + DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MGLMapView_Private.hpp; sourceTree = "<group>"; }; DAE6C3AD1CC31EF300DB3429 /* MGLMapView.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLMapView.mm; sourceTree = "<group>"; }; - DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "MGLMapView+IBAdditions.m"; sourceTree = "<group>"; }; + DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "MGLMapView+IBAdditions.mm"; sourceTree = "<group>"; }; DAE6C3AF1CC31EF300DB3429 /* MGLOpenGLLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLOpenGLLayer.h; sourceTree = "<group>"; }; DAE6C3B01CC31EF300DB3429 /* MGLOpenGLLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MGLOpenGLLayer.mm; sourceTree = "<group>"; }; DAE6C3BB1CC31F2E00DB3429 /* default_marker.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = default_marker.pdf; sourceTree = "<group>"; }; @@ -302,6 +419,85 @@ /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ + 35136D471D42295400C20EFD /* Layers */ = { + isa = PBXGroup; + children = ( + 3538AA211D542685008EC33D /* MGLBaseStyleLayer.h */, + 3538AA221D542685008EC33D /* MGLBaseStyleLayer.mm */, + DA8F25851D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h */, + DA8F25861D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm */, + 3527428B1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.h */, + 3527428C1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.mm */, + 35602BF81D3EA99F0050646F /* MGLFillStyleLayer.h */, + 35602BF91D3EA99F0050646F /* MGLFillStyleLayer.mm */, + DA8F25891D51CA540010E6B5 /* MGLLineStyleLayer.h */, + DA8F258A1D51CA540010E6B5 /* MGLLineStyleLayer.mm */, + DA8F258D1D51CA600010E6B5 /* MGLRasterStyleLayer.h */, + DA8F258E1D51CA600010E6B5 /* MGLRasterStyleLayer.mm */, + 35602BFD1D3EA9B40050646F /* MGLStyleLayer.h */, + 35602BFC1D3EA9B40050646F /* MGLStyleLayer_Private.hpp */, + 35602BFE1D3EA9B40050646F /* MGLStyleLayer.mm */, + DA8F25911D51CA750010E6B5 /* MGLSymbolStyleLayer.h */, + DA8F25921D51CA750010E6B5 /* MGLSymbolStyleLayer.mm */, + ); + name = Layers; + sourceTree = "<group>"; + }; + 352742791D4C235C00A1ECE6 /* Categories */ = { + isa = PBXGroup; + children = ( + DA8F25A21D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions_Private.hpp */, + DA8F25A01D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.h */, + DA8F25A11D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.mm */, + 3593E52C1D52A680006D9365 /* NSColor+MGLStyleAttributeAdditions_Private.hpp */, + 3527427A1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.h */, + 3527427B1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.m */, + DA8F259F1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp */, + DA8F259D1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.h */, + DA8F259E1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.mm */, + DA8F25A51D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions_Private.hpp */, + DA8F25A31D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.h */, + DA8F25A41D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.mm */, + DA8F25A81D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions_Private.hpp */, + DA8F25A61D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h */, + DA8F25A71D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm */, + ); + name = Categories; + sourceTree = "<group>"; + }; + 3527427E1D4C242B00A1ECE6 /* Sources */ = { + isa = PBXGroup; + children = ( + 3527427F1D4C243B00A1ECE6 /* MGLSource.h */, + DA8F25991D51CAD00010E6B5 /* MGLSource_Private.hpp */, + 352742801D4C243B00A1ECE6 /* MGLSource.mm */, + DA8F25951D51CAC70010E6B5 /* MGLVectorSource.h */, + DA8F25961D51CAC70010E6B5 /* MGLVectorSource.m */, + 352742871D4C245800A1ECE6 /* MGLGeoJSONSource.h */, + 352742881D4C245800A1ECE6 /* MGLGeoJSONSource.mm */, + 352742831D4C244700A1ECE6 /* MGLRasterSource.h */, + 352742841D4C244700A1ECE6 /* MGLRasterSource.mm */, + ); + name = Sources; + sourceTree = "<group>"; + }; + 3527429B1D4C259500A1ECE6 /* Styling */ = { + isa = PBXGroup; + children = ( + 352742791D4C235C00A1ECE6 /* Categories */, + 35136D471D42295400C20EFD /* Layers */, + 3527427E1D4C242B00A1ECE6 /* Sources */, + 3527429D1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.h */, + 3527429C1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction_Private.hpp */, + 3527429E1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.mm */, + 3593E5281D52A628006D9365 /* MGLStyleAttribute.hpp */, + 3593E5291D52A628006D9365 /* MGLStyleAttribute.mm */, + 352742771D4C220900A1ECE6 /* MGLStyleAttributeValue.h */, + DA8F259B1D51CB000010E6B5 /* MGLStyleAttributeValue_Private.hpp */, + ); + name = Styling; + sourceTree = "<group>"; + }; DA839E891CC2E3400062CAFB = { isa = PBXGroup; children = ( @@ -380,6 +576,44 @@ path = ../../darwin/resources; sourceTree = "<group>"; }; + DA8F257C1D51C5F40010E6B5 /* Layers */ = { + isa = PBXGroup; + children = ( + DA2DBBC71D51E26600D38FF9 /* MGLStyleLayerTests.h */, + DA2DBBC81D51E26600D38FF9 /* MGLStyleLayerTests.m */, + DA8F25741D51C5F40010E6B5 /* MGLFillStyleLayerTests.m */, + DA8F25751D51C5F40010E6B5 /* MGLRasterStyleLayerTests.m */, + DA8F25761D51C5F40010E6B5 /* MGLSymbolStyleLayerTests.m */, + DA8F25771D51C5F40010E6B5 /* MGLLineStyleLayerTests.m */, + DA8F25781D51C5F40010E6B5 /* MGLCircleStyleLayerTests.m */, + DA8F25791D51C5F40010E6B5 /* MGLBackgroundStyleLayerTests.m */, + DA8F257A1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.h */, + DA8F257B1D51C5F40010E6B5 /* MGLRuntimeStylingHelper.m */, + DA2DBBCA1D51E30A00D38FF9 /* MGLStyleLayerTests.xib */, + ); + name = Layers; + sourceTree = "<group>"; + }; + DA8F257D1D51C5F40010E6B5 /* Styling */ = { + isa = PBXGroup; + children = ( + DA8F257C1D51C5F40010E6B5 /* Layers */, + ); + name = Styling; + path = ../../ios/test; + sourceTree = "<group>"; + }; + DA8F25B81D51D2280010E6B5 /* Foundation Templates */ = { + isa = PBXGroup; + children = ( + DA8F25B51D51D2240010E6B5 /* MGLRuntimeStylingTests.m.ejs */, + DA8F25B61D51D2240010E6B5 /* MGLStyleLayer.h.ejs */, + DA8F25B71D51D2240010E6B5 /* MGLStyleLayer.mm.ejs */, + ); + name = "Foundation Templates"; + path = ../../darwin/src; + sourceTree = "<group>"; + }; DAD1657C1CF4CE6B001FF4B9 /* Formatters */ = { isa = PBXGroup; children = ( @@ -474,6 +708,7 @@ children = ( DAE6C3C11CC31F4500DB3429 /* Mapbox.h */, DAE6C3491CC31DF500DB3429 /* Foundation */, + DA8F25B81D51D2280010E6B5 /* Foundation Templates */, DA8933B21CCD2C0700E68420 /* Foundation Resources */, DAE6C39E1CC31E7C00DB3429 /* Kit */, DA8933A81CCD28D100E68420 /* Kit Resources */, @@ -486,6 +721,7 @@ DAE6C3371CC30DB200DB3429 /* SDK Tests */ = { isa = PBXGroup; children = ( + DA8F257D1D51C5F40010E6B5 /* Styling */, DA35A2C11CCA9F4A00E826B2 /* MGLClockDirectionFormatterTests.m */, DA35A2B51CCA14D700E826B2 /* MGLCompassDirectionFormatterTests.m */, DA35A2A71CC9F41600E826B2 /* MGLCoordinateFormatterTests.m */, @@ -504,6 +740,7 @@ DAE6C3491CC31DF500DB3429 /* Foundation */ = { isa = PBXGroup; children = ( + 3527429B1D4C259500A1ECE6 /* Styling */, DAD1657F1CF4CF50001FF4B9 /* Categories */, DAD1657C1CF4CE6B001FF4B9 /* Formatters */, DAD1657D1CF4CECB001FF4B9 /* Geometry */, @@ -514,6 +751,7 @@ DAE6C34D1CC31E0400DB3429 /* MGLMapCamera.h */, DAE6C36E1CC31E2A00DB3429 /* MGLMapCamera.mm */, DAE6C3571CC31E0400DB3429 /* MGLStyle.h */, + 3537CA731D3F93A600380318 /* MGLStyle_Private.hpp */, DAE6C37A1CC31E2A00DB3429 /* MGLStyle.mm */, DAE6C3591CC31E0400DB3429 /* MGLTypes.h */, DAE6C37C1CC31E2A00DB3429 /* MGLTypes.m */, @@ -533,13 +771,15 @@ DAE6C3AA1CC31EF300DB3429 /* MGLCompassCell.h */, DAE6C3AB1CC31EF300DB3429 /* MGLCompassCell.m */, DAE6C3A01CC31E9400DB3429 /* MGLMapView.h */, - DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.h */, + DAE6C3AC1CC31EF300DB3429 /* MGLMapView_Private.hpp */, DAE6C3AD1CC31EF300DB3429 /* MGLMapView.mm */, DAE6C3A11CC31E9400DB3429 /* MGLMapView+IBAdditions.h */, - DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.m */, + DAE6C3AE1CC31EF300DB3429 /* MGLMapView+IBAdditions.mm */, DAE6C3A21CC31E9400DB3429 /* MGLMapViewDelegate.h */, DAE6C3AF1CC31EF300DB3429 /* MGLOpenGLLayer.h */, DAE6C3B01CC31EF300DB3429 /* MGLOpenGLLayer.mm */, + 355BA4EB1D41633E00CCC6D5 /* NSColor+MGLAdditions.hpp */, + 355BA4EC1D41633E00CCC6D5 /* NSColor+MGLAdditions.mm */, ); name = Kit; path = src; @@ -560,48 +800,79 @@ isa = PBXHeadersBuildPhase; buildActionMask = 2147483647; files = ( + 3593E52D1D52A680006D9365 /* NSColor+MGLStyleAttributeAdditions_Private.hpp in Headers */, + DA8F258F1D51CA600010E6B5 /* MGLRasterStyleLayer.h in Headers */, DAE6C38D1CC31E2A00DB3429 /* MGLOfflineRegion_Private.h in Headers */, + DA8F25AB1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions_Private.hpp in Headers */, + DA8F259C1D51CB000010E6B5 /* MGLStyleAttributeValue_Private.hpp in Headers */, + DA8F25B41D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions_Private.hpp in Headers */, DAE6C35B1CC31E0400DB3429 /* MGLAnnotation.h in Headers */, - DAE6C3B61CC31EF300DB3429 /* MGLMapView_Private.h in Headers */, + DAE6C3B61CC31EF300DB3429 /* MGLMapView_Private.hpp in Headers */, + 3527428D1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.h in Headers */, DAE6C3B21CC31EF300DB3429 /* MGLAttributionButton.h in Headers */, DAE6C3A31CC31E9400DB3429 /* MGLAnnotationImage.h in Headers */, DAE6C3A41CC31E9400DB3429 /* MGLMapView.h in Headers */, + 352742A01D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.h in Headers */, + 355BA4ED1D41633E00CCC6D5 /* NSColor+MGLAdditions.hpp in Headers */, DAE6C3611CC31E0400DB3429 /* MGLOfflineStorage.h in Headers */, + 352742781D4C220900A1ECE6 /* MGLStyleAttributeValue.h in Headers */, DAE6C35E1CC31E0400DB3429 /* MGLMultiPoint.h in Headers */, + 35602BFF1D3EA9B40050646F /* MGLStyleLayer_Private.hpp in Headers */, DAE6C3971CC31E2A00DB3429 /* NSBundle+MGLAdditions.h in Headers */, DAD165741CF4CD7A001FF4B9 /* MGLShapeCollection.h in Headers */, + DA8F25AF1D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.h in Headers */, DAE6C3631CC31E0400DB3429 /* MGLPointAnnotation.h in Headers */, DAC2ABC51CC6D343006D18C4 /* MGLAnnotationImage_Private.h in Headers */, DAE6C35F1CC31E0400DB3429 /* MGLOfflinePack.h in Headers */, DAE6C39C1CC31E2A00DB3429 /* NSString+MGLAdditions.h in Headers */, + DA8F25971D51CAC70010E6B5 /* MGLVectorSource.h in Headers */, DAE6C3861CC31E2A00DB3429 /* MGLGeometry_Private.h in Headers */, DAE6C3841CC31E2A00DB3429 /* MGLAccountManager_Private.h in Headers */, DAE6C3691CC31E0400DB3429 /* MGLTypes.h in Headers */, + DA8F25AE1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions_Private.hpp in Headers */, DAE6C3991CC31E2A00DB3429 /* NSException+MGLAdditions.h in Headers */, + DA8F25871D51C9E10010E6B5 /* MGLBackgroundStyleLayer.h in Headers */, DAE6C3661CC31E0400DB3429 /* MGLShape.h in Headers */, + 352742811D4C243B00A1ECE6 /* MGLSource.h in Headers */, DAE6C3C21CC31F4500DB3429 /* Mapbox.h in Headers */, + 3527427C1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.h in Headers */, DAE6C3641CC31E0400DB3429 /* MGLPolygon.h in Headers */, DA35A2BF1CCA9B1A00E826B2 /* MGLClockDirectionFormatter.h in Headers */, + 35602BFA1D3EA99F0050646F /* MGLFillStyleLayer.h in Headers */, DA35A2A41CC9EB1A00E826B2 /* MGLCoordinateFormatter.h in Headers */, + DA8F25B11D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions_Private.hpp in Headers */, + 3593E52A1D52A628006D9365 /* MGLStyleAttribute.hpp in Headers */, DAE6C3621CC31E0400DB3429 /* MGLOverlay.h in Headers */, DAE6C3651CC31E0400DB3429 /* MGLPolyline.h in Headers */, DAE6C39A1CC31E2A00DB3429 /* NSProcessInfo+MGLAdditions.h in Headers */, + DA8F258B1D51CA540010E6B5 /* MGLLineStyleLayer.h in Headers */, + DA8F25B21D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.h in Headers */, DAE6C38E1CC31E2A00DB3429 /* MGLOfflineStorage_Private.h in Headers */, DAE6C3601CC31E0400DB3429 /* MGLOfflineRegion.h in Headers */, DAE6C3681CC31E0400DB3429 /* MGLTilePyramidOfflineRegion.h in Headers */, + DA8F25AC1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.h in Headers */, + 3527429F1D4C25BD00A1ECE6 /* MGLStyleAttributeFunction_Private.hpp in Headers */, DA35A2CF1CCAAED300E826B2 /* NSValue+MGLAdditions.h in Headers */, DAE6C3A61CC31E9400DB3429 /* MGLMapViewDelegate.h in Headers */, DAE6C38B1CC31E2A00DB3429 /* MGLOfflinePack_Private.h in Headers */, DACC22141CF3D3E200D220D9 /* MGLFeature.h in Headers */, + 3538AA231D542685008EC33D /* MGLBaseStyleLayer.h in Headers */, DAE6C35C1CC31E0400DB3429 /* MGLGeometry.h in Headers */, DAE6C35A1CC31E0400DB3429 /* MGLAccountManager.h in Headers */, + 35602C001D3EA9B40050646F /* MGLStyleLayer.h in Headers */, DAE6C35D1CC31E0400DB3429 /* MGLMapCamera.h in Headers */, DAE6C3B41CC31EF300DB3429 /* MGLCompassCell.h in Headers */, + DA8F25A91D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.h in Headers */, + 3537CA741D3F93A600380318 /* MGLStyle_Private.hpp in Headers */, + DA8F259A1D51CAD00010E6B5 /* MGLSource_Private.hpp in Headers */, + DA8F25931D51CA750010E6B5 /* MGLSymbolStyleLayer.h in Headers */, DAE6C3B91CC31EF300DB3429 /* MGLOpenGLLayer.h in Headers */, DAE6C3891CC31E2A00DB3429 /* MGLMultiPoint_Private.h in Headers */, DAE6C3A51CC31E9400DB3429 /* MGLMapView+IBAdditions.h in Headers */, DA35A2AD1CCA091800E826B2 /* MGLCompassDirectionFormatter.h in Headers */, + 352742851D4C244700A1ECE6 /* MGLRasterSource.h in Headers */, DACC22181CF3D4F700D220D9 /* MGLFeature_Private.h in Headers */, + 352742891D4C245800A1ECE6 /* MGLGeoJSONSource.h in Headers */, DAE6C3671CC31E0400DB3429 /* MGLStyle.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; @@ -756,6 +1027,7 @@ isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( + DA2DBBCB1D51E30A00D38FF9 /* MGLStyleLayerTests.xib in Resources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -782,32 +1054,52 @@ files = ( DAE6C3901CC31E2A00DB3429 /* MGLPointAnnotation.m in Sources */, DAE6C3981CC31E2A00DB3429 /* NSBundle+MGLAdditions.m in Sources */, + DA8F25AA1D51CB270010E6B5 /* NSNumber+MGLStyleAttributeAdditions.mm in Sources */, DAE6C3B71CC31EF300DB3429 /* MGLMapView.mm in Sources */, DAE6C38C1CC31E2A00DB3429 /* MGLOfflinePack.mm in Sources */, DAE6C3B11CC31EF300DB3429 /* MGLAnnotationImage.m in Sources */, DACC22151CF3D3E200D220D9 /* MGLFeature.mm in Sources */, + 355BA4EE1D41633E00CCC6D5 /* NSColor+MGLAdditions.mm in Sources */, DAE6C3B31CC31EF300DB3429 /* MGLAttributionButton.m in Sources */, + 35602BFB1D3EA99F0050646F /* MGLFillStyleLayer.mm in Sources */, DAE6C3931CC31E2A00DB3429 /* MGLShape.m in Sources */, + 352742861D4C244700A1ECE6 /* MGLRasterSource.mm in Sources */, DAE6C39D1CC31E2A00DB3429 /* NSString+MGLAdditions.m in Sources */, DAE6C3941CC31E2A00DB3429 /* MGLStyle.mm in Sources */, DAE6C3871CC31E2A00DB3429 /* MGLGeometry.mm in Sources */, - DAE6C3B81CC31EF300DB3429 /* MGLMapView+IBAdditions.m in Sources */, + 3527428E1D4C24AB00A1ECE6 /* MGLCircleStyleLayer.mm in Sources */, + 35602C011D3EA9B40050646F /* MGLStyleLayer.mm in Sources */, + 3527427D1D4C238F00A1ECE6 /* NSColor+MGLStyleAttributeAdditions.m in Sources */, + DA8F25881D51C9E10010E6B5 /* MGLBackgroundStyleLayer.mm in Sources */, + DAE6C3B81CC31EF300DB3429 /* MGLMapView+IBAdditions.mm in Sources */, DA35A2D01CCAAED300E826B2 /* NSValue+MGLAdditions.m in Sources */, + 3538AA241D542685008EC33D /* MGLBaseStyleLayer.mm in Sources */, DA35A2C01CCA9B1A00E826B2 /* MGLClockDirectionFormatter.m in Sources */, DAE6C3BA1CC31EF300DB3429 /* MGLOpenGLLayer.mm in Sources */, DAE6C38A1CC31E2A00DB3429 /* MGLMultiPoint.mm in Sources */, DAE6C3961CC31E2A00DB3429 /* MGLTypes.m in Sources */, DA35A2A61CC9EB2700E826B2 /* MGLCoordinateFormatter.m in Sources */, + 352742821D4C243B00A1ECE6 /* MGLSource.mm in Sources */, DAE6C3881CC31E2A00DB3429 /* MGLMapCamera.mm in Sources */, + DA8F25B31D51CB270010E6B5 /* NSValue+MGLStyleAttributeAdditions.mm in Sources */, DAE6C3911CC31E2A00DB3429 /* MGLPolygon.mm in Sources */, DAE6C39B1CC31E2A00DB3429 /* NSProcessInfo+MGLAdditions.m in Sources */, DAE6C38F1CC31E2A00DB3429 /* MGLOfflineStorage.mm in Sources */, DAE6C3951CC31E2A00DB3429 /* MGLTilePyramidOfflineRegion.mm in Sources */, + 3593E52B1D52A628006D9365 /* MGLStyleAttribute.mm in Sources */, DAE6C3851CC31E2A00DB3429 /* MGLAccountManager.m in Sources */, + DA8F25B01D51CB270010E6B5 /* NSString+MGLStyleAttributeAdditions.mm in Sources */, DAE6C3921CC31E2A00DB3429 /* MGLPolyline.mm in Sources */, + 3527428A1D4C245800A1ECE6 /* MGLGeoJSONSource.mm in Sources */, DAE6C3B51CC31EF300DB3429 /* MGLCompassCell.m in Sources */, + DA8F25901D51CA600010E6B5 /* MGLRasterStyleLayer.mm in Sources */, DAD165751CF4CD7A001FF4B9 /* MGLShapeCollection.m in Sources */, DA35A2AE1CCA091800E826B2 /* MGLCompassDirectionFormatter.m in Sources */, + DA8F258C1D51CA540010E6B5 /* MGLLineStyleLayer.mm in Sources */, + DA8F25AD1D51CB270010E6B5 /* NSArray+MGLStyleAttributeAdditions.mm in Sources */, + DA8F25941D51CA750010E6B5 /* MGLSymbolStyleLayer.mm in Sources */, + DA8F25981D51CAC70010E6B5 /* MGLVectorSource.m in Sources */, + 352742A11D4C25BD00A1ECE6 /* MGLStyleAttributeFunction.mm in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/platform/macos/src/MGLMapView+IBAdditions.m b/platform/macos/src/MGLMapView+IBAdditions.mm index eada47ef90..2df0d228ff 100644 --- a/platform/macos/src/MGLMapView+IBAdditions.m +++ b/platform/macos/src/MGLMapView+IBAdditions.mm @@ -1,6 +1,6 @@ #import "MGLMapView+IBAdditions.h" -#import "MGLMapView_Private.h" +#import "MGLMapView_Private.hpp" @implementation MGLMapView (IBAdditions) diff --git a/platform/macos/src/MGLMapView.h b/platform/macos/src/MGLMapView.h index 7c464fe83a..9d44632196 100644 --- a/platform/macos/src/MGLMapView.h +++ b/platform/macos/src/MGLMapView.h @@ -35,6 +35,7 @@ typedef NS_OPTIONS(NSUInteger, MGLMapDebugMaskOptions) { @class MGLAnnotationImage; @class MGLMapCamera; +@class MGLStyle; @protocol MGLAnnotation; @protocol MGLMapViewDelegate; @@ -931,6 +932,10 @@ IB_DESIGNABLE */ @property (nonatomic) MGLMapDebugMaskOptions debugMask; +#pragma mark Runtime styling API + +- (MGLStyle *)style; + @end NS_ASSUME_NONNULL_END diff --git a/platform/macos/src/MGLMapView.mm b/platform/macos/src/MGLMapView.mm index 7b0aad1db9..c9f295d7e7 100644 --- a/platform/macos/src/MGLMapView.mm +++ b/platform/macos/src/MGLMapView.mm @@ -1,4 +1,4 @@ -#import "MGLMapView_Private.h" +#import "MGLMapView_Private.hpp" #import "MGLAnnotationImage_Private.h" #import "MGLAttributionButton.h" #import "MGLCompassCell.h" @@ -9,6 +9,7 @@ #import "MGLGeometry_Private.h" #import "MGLMultiPoint_Private.h" #import "MGLOfflineStorage_Private.h" +#import "MGLStyle_Private.hpp" #import "MGLAccountManager.h" #import "MGLMapCamera.h" @@ -36,6 +37,7 @@ #import "NSProcessInfo+MGLAdditions.h" #import "NSException+MGLAdditions.h" #import "NSString+MGLAdditions.h" +#import "NSColor+MGLAdditions.hpp" #import <QuartzCore/QuartzCore.h> @@ -123,16 +125,6 @@ mbgl::util::UnitBezier MGLUnitBezierForMediaTimingFunction(CAMediaTimingFunction return { p1[0], p1[1], p2[0], p2[1] }; } -/// Converts the given color into an mbgl::Color in calibrated RGB space. -mbgl::Color MGLColorObjectFromNSColor(NSColor *color) { - if (!color) { - return { 0, 0, 0, 0 }; - } - CGFloat r, g, b, a; - [[color colorUsingColorSpaceName:NSCalibratedRGBColorSpace] getRed:&r green:&g blue:&b alpha:&a]; - return { (float)r, (float)g, (float)b, (float)a }; -} - /// Lightweight container for metadata about an annotation, including the annotation itself. class MGLAnnotationContext { public: @@ -2127,6 +2119,20 @@ public: } } +#pragma mark - Runtime styling + +- (MGLStyle *)style +{ + MGLStyle *style = [[MGLStyle alloc] init]; + style.mapView = self; + return style; +} + +- (mbgl::Map *)mbglMap +{ + return _mbglMap; +} + #pragma mark MGLMultiPointDelegate methods - (double)alphaForShapeAnnotation:(MGLShape *)annotation { @@ -2140,14 +2146,14 @@ public: NSColor *color = (_delegateHasStrokeColorsForShapeAnnotations ? [self.delegate mapView:self strokeColorForShapeAnnotation:annotation] : [NSColor selectedMenuItemColor]); - return MGLColorObjectFromNSColor(color); + return color.mbgl_color; } - (mbgl::Color)fillColorForPolygonAnnotation:(MGLPolygon *)annotation { NSColor *color = (_delegateHasFillColorsForShapeAnnotations ? [self.delegate mapView:self fillColorForPolygonAnnotation:annotation] : [NSColor selectedMenuItemColor]); - return MGLColorObjectFromNSColor(color); + return color.mbgl_color; } - (CGFloat)lineWidthForPolylineAnnotation:(MGLPolyline *)annotation { diff --git a/platform/macos/src/MGLMapView_Private.h b/platform/macos/src/MGLMapView_Private.hpp index 76b1727925..2d9fc52a62 100644 --- a/platform/macos/src/MGLMapView_Private.h +++ b/platform/macos/src/MGLMapView_Private.hpp @@ -1,5 +1,7 @@ #import "MGLMapView.h" +#import <mbgl/mbgl.hpp> + @interface MGLMapView (Private) /// True if the view or application is in a state where it is not expected to be @@ -20,4 +22,6 @@ /// Synchronously render a frame of the map. - (void)renderSync; +- (mbgl::Map *)mbglMap; + @end diff --git a/platform/macos/src/MGLOpenGLLayer.mm b/platform/macos/src/MGLOpenGLLayer.mm index e8fa521351..0abfa4f672 100644 --- a/platform/macos/src/MGLOpenGLLayer.mm +++ b/platform/macos/src/MGLOpenGLLayer.mm @@ -1,6 +1,6 @@ #import "MGLOpenGLLayer.h" -#import "MGLMapView_Private.h" +#import "MGLMapView_Private.hpp" #import <mbgl/gl/gl.hpp> diff --git a/platform/macos/src/Mapbox.h b/platform/macos/src/Mapbox.h index e4545e04bc..0217bca44a 100644 --- a/platform/macos/src/Mapbox.h +++ b/platform/macos/src/Mapbox.h @@ -29,6 +29,25 @@ FOUNDATION_EXPORT const unsigned char MapboxVersionString[]; #import "MGLShape.h" #import "MGLShapeCollection.h" #import "MGLStyle.h" +#import "MGLStyleLayer.h" +#import "MGLBaseStyleLayer.h" +#import "MGLFillStyleLayer.h" +#import "MGLLineStyleLayer.h" +#import "MGLSymbolStyleLayer.h" +#import "MGLRasterStyleLayer.h" +#import "MGLCircleStyleLayer.h" +#import "MGLBackgroundStyleLayer.h" +#import "MGLSource.h" +#import "MGLVectorSource.h" +#import "MGLGeoJSONSource.h" +#import "MGLRasterSource.h" #import "MGLTilePyramidOfflineRegion.h" #import "MGLTypes.h" #import "NSValue+MGLAdditions.h" +#import "MGLStyleAttributeValue.h" +#import "MGLStyleAttributeFunction.h" +#import "NSColor+MGLStyleAttributeAdditions.h" +#import "NSNumber+MGLStyleAttributeAdditions.h" +#import "NSValue+MGLStyleAttributeAdditions.h" +#import "NSString+MGLStyleAttributeAdditions.h" +#import "NSArray+MGLStyleAttributeAdditions.h" diff --git a/platform/macos/src/NSColor+MGLAdditions.hpp b/platform/macos/src/NSColor+MGLAdditions.hpp new file mode 100644 index 0000000000..2ba38f7d90 --- /dev/null +++ b/platform/macos/src/NSColor+MGLAdditions.hpp @@ -0,0 +1,20 @@ +#import <Cocoa/Cocoa.h> + +#include <mbgl/util/color.hpp> +#include <mbgl/style/property_value.hpp> + +@interface NSColor (MGLAdditions) + +/** + Converts the color into an mbgl::Color in calibrated RGB space. + */ +- (mbgl::Color)mbgl_color; + +/** + Instantiates `NSColor` from an `mbgl::Color` + */ ++ (NSColor *)mbgl_colorWithColor:(mbgl::Color)color; + +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue; + +@end diff --git a/platform/macos/src/NSColor+MGLAdditions.mm b/platform/macos/src/NSColor+MGLAdditions.mm new file mode 100644 index 0000000000..4c3c116418 --- /dev/null +++ b/platform/macos/src/NSColor+MGLAdditions.mm @@ -0,0 +1,29 @@ +#import "NSColor+MGLAdditions.hpp" + +@implementation NSColor (MGLAdditions) + +- (mbgl::Color)mbgl_color +{ + if (!self) + { + return { 0, 0, 0, 0 }; + } + CGFloat r, g, b, a; + + [[self colorUsingColorSpaceName:NSCalibratedRGBColorSpace] getRed:&r green:&g blue:&b alpha:&a]; + + return { (float)r, (float)g, (float)b, (float)a }; +} + ++ (NSColor *)mbgl_colorWithColor:(mbgl::Color)color +{ + return [NSColor colorWithRed:color.r green:color.g blue:color.b alpha:color.a]; +} + +- (mbgl::style::PropertyValue<mbgl::Color>)mbgl_colorPropertyValue +{ + mbgl::Color color = self.mbgl_color; + return {{ color.r, color.g, color.b, color.a }}; +} + +@end |