11 files changed, 477 insertions, 0 deletions
diff --git a/platform/darwin/include/MGLAnnotation.h b/platform/darwin/include/MGLAnnotation.h
new file mode 100644
index 0000000000..e4726f9503
--- /dev/null
+++ b/platform/darwin/include/MGLAnnotation.h
@@ -0,0 +1,48 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+#import <TargetConditionals.h>
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ The `MGLAnnotation` protocol is used to provide annotation-related information to a map view. To use this protocol, you adopt it in any custom objects that store or represent annotation data. Each object then serves as the source of information about a single map annotation and provides critical information, such as the annotation’s location on the map. Annotation objects do not provide the visual representation of the annotation but typically coordinate (in conjunction with the map view’s delegate) the creation of an appropriate objects to handle the display.
+ 
+ An object that adopts this protocol must implement the `coordinate` property. The other methods of this protocol are optional.
+ */
+@protocol MGLAnnotation <NSObject>
+
+#pragma mark Position Attributes
+
+/** The center point (specified as a map coordinate) of the annotation. (required) (read-only) */
+@property (nonatomic, readonly) CLLocationCoordinate2D coordinate;
+
+@optional
+
+#pragma mark Title Attributes
+
+/**
+ The string containing the annotation’s title.
+ 
+ Although this property is optional, if you support the selection of annotations in your map view, you are expected to provide this property. This string is displayed in the callout for the associated annotation.
+ */
+@property (nonatomic, readonly, copy, nullable) NSString *title;
+
+/**
+ The string containing the annotation’s subtitle.
+ 
+ This string is displayed in the callout for the associated annotation.
+ */
+@property (nonatomic, readonly, copy, nullable) NSString *subtitle;
+
+#if !TARGET_OS_IPHONE
+
+/** The string containing the annotation’s tooltip. */
+@property (nonatomic, readonly, copy, nullable) NSString *toolTip;
+
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLGeometry.h b/platform/darwin/include/MGLGeometry.h
new file mode 100644
index 0000000000..8cb1da10fc
--- /dev/null
+++ b/platform/darwin/include/MGLGeometry.h
@@ -0,0 +1,98 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+#import <CoreGraphics/CGBase.h>
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** Defines the area spanned by an `MGLCoordinateBounds`. */
+typedef struct MGLCoordinateSpan {
+    /** Latitudes spanned by an `MGLCoordinateBounds`. */
+    CLLocationDegrees latitudeDelta;
+    /** Longitudes spanned by an `MGLCoordinateBounds`. */
+    CLLocationDegrees longitudeDelta;
+} MGLCoordinateSpan;
+
+/** Creates a new `MGLCoordinateSpan` from the given latitudinal and longitudinal deltas. */
+NS_INLINE MGLCoordinateSpan MGLCoordinateSpanMake(CLLocationDegrees latitudeDelta, CLLocationDegrees longitudeDelta) {
+    MGLCoordinateSpan span;
+    span.latitudeDelta = latitudeDelta;
+    span.longitudeDelta = longitudeDelta;
+    return span;
+}
+
+/** Returns `YES` if the two coordinate spans represent the same latitudinal change and the same longitudinal change. */
+NS_INLINE BOOL MGLCoordinateSpanEqualToCoordinateSpan(MGLCoordinateSpan span1, MGLCoordinateSpan span2) {
+    return (span1.latitudeDelta == span2.latitudeDelta &&
+            span1.longitudeDelta == span2.longitudeDelta);
+}
+
+/** An area of zero width and zero height. */
+extern const MGLCoordinateSpan MGLCoordinateSpanZero;
+
+/** A rectangular area as measured on a two-dimensional map projection. */
+typedef struct MGLCoordinateBounds {
+    /** Coordinate at the southwest corner. */
+    CLLocationCoordinate2D sw;
+    /** Coordinate at the northeast corner. */
+    CLLocationCoordinate2D ne;
+} MGLCoordinateBounds;
+
+/** Creates a new `MGLCoordinateBounds` structure from the given southwest and northeast coordinates. */
+NS_INLINE MGLCoordinateBounds MGLCoordinateBoundsMake(CLLocationCoordinate2D sw, CLLocationCoordinate2D ne) {
+    MGLCoordinateBounds bounds;
+    bounds.sw = sw;
+    bounds.ne = ne;
+    return bounds;
+}
+
+/** Returns `YES` if the two coordinate bounds are equal to each other. */
+NS_INLINE BOOL MGLCoordinateBoundsEqualToCoordinateBounds(MGLCoordinateBounds bounds1, MGLCoordinateBounds bounds2) {
+    return (bounds1.sw.latitude == bounds2.sw.latitude &&
+            bounds1.sw.longitude == bounds2.sw.longitude &&
+            bounds1.ne.latitude == bounds2.ne.latitude &&
+            bounds1.ne.longitude == bounds2.ne.longitude);
+}
+
+/** Returns the area spanned by the coordinate bounds. */
+NS_INLINE MGLCoordinateSpan MGLCoordinateBoundsGetCoordinateSpan(MGLCoordinateBounds bounds) {
+    return MGLCoordinateSpanMake(bounds.ne.latitude - bounds.sw.latitude,
+                                 bounds.ne.longitude - bounds.sw.longitude);
+}
+
+/** Returns a coordinate bounds with southwest and northeast coordinates that are offset from those of the source bounds. */
+NS_INLINE MGLCoordinateBounds MGLCoordinateBoundsOffset(MGLCoordinateBounds bounds, MGLCoordinateSpan offset) {
+    MGLCoordinateBounds offsetBounds = bounds;
+    offsetBounds.sw.latitude += offset.latitudeDelta;
+    offsetBounds.sw.longitude += offset.longitudeDelta;
+    offsetBounds.ne.latitude += offset.latitudeDelta;
+    offsetBounds.ne.longitude += offset.longitudeDelta;
+    return offsetBounds;
+}
+
+/** Returns `YES` if the coordinate bounds covers no area.
+  Note that a bounds may be empty but have a non-zero coordinate span (e.g., when its northeast point lies due north of its southwest point). */
+NS_INLINE BOOL MGLCoordinateBoundsIsEmpty(MGLCoordinateBounds bounds) {
+    MGLCoordinateSpan span = MGLCoordinateBoundsGetCoordinateSpan(bounds);
+    return span.latitudeDelta == 0 || span.longitudeDelta == 0;
+}
+
+/** Returns a formatted string for the given coordinate bounds. */
+NS_INLINE NSString *MGLStringFromCoordinateBounds(MGLCoordinateBounds bounds) {
+    return [NSString stringWithFormat:@"{{%.1f, %.1f}, {%.1f, %.1f}}",
+            bounds.sw.latitude, bounds.sw.longitude,
+            bounds.ne.latitude, bounds.ne.longitude];
+}
+
+/** Returns radians, converted from degrees. */
+NS_INLINE CGFloat MGLRadiansFromDegrees(CLLocationDegrees degrees) {
+    return (CGFloat)(degrees * M_PI) / 180;
+}
+
+/** Returns degrees, converted from radians. */
+NS_INLINE CLLocationDegrees MGLDegreesFromRadians(CGFloat radians) {
+    return radians * 180 / M_PI;
+}
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLMapCamera.h b/platform/darwin/include/MGLMapCamera.h
new file mode 100644
index 0000000000..3cb902ba52
--- /dev/null
+++ b/platform/darwin/include/MGLMapCamera.h
@@ -0,0 +1,53 @@
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** An `MGLMapCamera` object represents a viewpoint from which the user observes some point on an `MGLMapView`. */
+@interface MGLMapCamera : NSObject <NSSecureCoding, NSCopying>
+
+/** Coordinate at the center of the map view. */
+@property (nonatomic) CLLocationCoordinate2D centerCoordinate;
+
+/** Heading measured in degrees clockwise from true north. */
+@property (nonatomic) CLLocationDirection heading;
+
+/** Pitch toward the horizon measured in degrees, with 0 degrees resulting in a two-dimensional map. */
+@property (nonatomic) CGFloat pitch;
+
+/** Meters above ground level. */
+@property (nonatomic) CLLocationDistance altitude;
+
+/** Returns a new camera with all properties set to 0. */
++ (instancetype)camera;
+
+/**
+ Returns a new camera using based on information about the camera’s viewpoint and focus point.
+ 
+ @param centerCoordinate The geographic coordinate on which the map should be centered.
+ @param eyeCoordinate The geometric coordinate at which the camera should be situated.
+ @param eyeAltitude The altitude (measured in meters) above the map at which the camera should be situated. The altitude may be less than the distance from the camera’s viewpoint to the camera’s focus point.
+ */
++ (instancetype)cameraLookingAtCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
+                              fromEyeCoordinate:(CLLocationCoordinate2D)eyeCoordinate
+                                    eyeAltitude:(CLLocationDistance)eyeAltitude;
+
+/**
+ Returns a new camera with the given distance, pitch, and heading.
+ 
+ @param centerCoordinate The geographic coordinate on which the map should be centered.
+ @param distance The straight-line distance from the viewpoint to the `centerCoordinate`.
+ @param pitch The viewing angle of the camera, measured in degrees. A value of `0` results in a camera pointed straight down at the map. Angles greater than `0` result in a camera angled toward the horizon.
+ @param heading The camera’s heading, measured in degrees clockwise from true north. A value of `0` means that the top edge of the map view corresponds to true north. The value `90` means the top of the map is pointing due east. The value `180` means the top of the map points due south, and so on.
+ */
++ (instancetype)cameraLookingAtCenterCoordinate:(CLLocationCoordinate2D)centerCoordinate
+                                   fromDistance:(CLLocationDistance)distance
+                                          pitch:(CGFloat)pitch
+                                        heading:(CLLocationDirection)heading;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLMultiPoint.h b/platform/darwin/include/MGLMultiPoint.h
new file mode 100644
index 0000000000..ad9db1e681
--- /dev/null
+++ b/platform/darwin/include/MGLMultiPoint.h
@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLShape.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The `MGLMultiPoint` class is an abstract superclass used to define shapes composed of multiple points. You should not create instances of this class directly. Instead, you should create instances of the `MGLPolyline` or `MGLPolygon` classes. However, you can use the method and properties of this class to access information about the specific points associated with the line or polygon. */
+@interface MGLMultiPoint : MGLShape
+
+/** The number of points associated with the shape. (read-only) */
+@property (nonatomic, readonly) NSUInteger pointCount;
+
+/**
+ Retrieves one or more coordinates associated with the shape.
+ 
+ @param coords On input, you must provide a C array of structures large enough to hold the desired number of coordinates. On output, this structure contains the requested coordinate data.
+ @param range The range of points you want. The `location` field indicates the first point you are requesting, with `0` being the first point, `1` being the second point, and so on. The `length` field indicates the number of points you want. The array in _`coords`_ must be large enough to accommodate the number of requested coordinates.
+ */
+- (void)getCoordinates:(CLLocationCoordinate2D *)coords range:(NSRange)range;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLOverlay.h b/platform/darwin/include/MGLOverlay.h
new file mode 100644
index 0000000000..aa80fe3900
--- /dev/null
+++ b/platform/darwin/include/MGLOverlay.h
@@ -0,0 +1,46 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLAnnotation.h"
+#import "MGLGeometry.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ The `MGLOverlay` protocol defines a specific type of annotation that represents both a point and an area on a map. Overlay objects are essentially data objects that contain the geographic data needed to represent the map area. For example, overlays can take the form of common shapes such as rectangles and circles. They can also describe polygons and other complex shapes.
+ 
+ You use overlays to layer more sophisticated content on top of a map view. For example, you could use an overlay to show the boundaries of a national park or trace a bus route along city streets. The Mapbox iOS SDK defines several concrete classes that conform to this protocol and define standard shapes.
+ 
+ Because overlays are also annotations, they have similar usage pattern to annotations. When added to a map view using the `-addOverlay:` method, that view detects whenever the overlay’s defined region intersects the visible portion of the map. At that point, the map view asks its delegate to provide a special overlay view to draw the visual representation of the overlay. If you add an overlay to a map view as an annotation instead, it is treated as an annotation with a single point.
+ */
+@protocol MGLOverlay <MGLAnnotation>
+
+/**
+ The approximate center point of the overlay area. (required) (read-only)
+ 
+ This point is typically set to the center point of the map’s bounding rectangle. It is used as the anchor point for any callouts displayed for the annotation.
+ */
+@property (nonatomic, readonly) CLLocationCoordinate2D coordinate;
+
+/**
+ The cooordinate rectangle that encompasses the overlay. (required) (read-only)
+ 
+ This property contains the smallest rectangle that completely encompasses the overlay. Implementers of this protocol must set this area when implementing their overlay class, and after setting it, you must not change it.
+ */
+@property (nonatomic, readonly) MGLCoordinateBounds overlayBounds;
+
+/**
+ Returns a Boolean indicating whether the specified rectangle intersects the receiver’s shape.
+ 
+ You can implement this method to provide more specific bounds checking for an overlay. If you do not implement it, the bounding rectangle is used to detect intersections.
+ 
+ @param overlayBounds The rectangle to intersect with the receiver’s area.
+ @return `YES` if any part of the map rectangle intersects the receiver’s shape or `NO` if it does not.
+ */
+- (BOOL)intersectsOverlayBounds:(MGLCoordinateBounds)overlayBounds;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLPointAnnotation.h b/platform/darwin/include/MGLPointAnnotation.h
new file mode 100644
index 0000000000..d186cbff18
--- /dev/null
+++ b/platform/darwin/include/MGLPointAnnotation.h
@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLShape.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The `MGLPointAnnotation` class defines a concrete annotation object located at a specified point. You can use this class, rather than define your own, in situations where all you want to do is associate a point on the map with a title. */
+@interface MGLPointAnnotation : MGLShape
+
+/** The coordinate point of the annotation, specified as a latitude and longitude. */
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLPolygon.h b/platform/darwin/include/MGLPolygon.h
new file mode 100644
index 0000000000..c5480264fb
--- /dev/null
+++ b/platform/darwin/include/MGLPolygon.h
@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLMultiPoint.h"
+#import "MGLOverlay.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The `MGLPolygon` class represents a shape consisting of one or more points that define a closed polygon. The points are connected end-to-end in the order they are provided. The first and last points are connected to each other to create the closed shape. */
+@interface MGLPolygon : MGLMultiPoint <MGLOverlay>
+
+/**
+ Creates and returns an `MGLPolygon` object from the specified set of coordinates.
+ 
+ @param coords The array of coordinates defining the shape. The data in this array is copied to the new object.
+ @param count The number of items in the `coords` array.
+ @return A new polygon object.
+ */
++ (instancetype)polygonWithCoordinates:(CLLocationCoordinate2D *)coords
+                                 count:(NSUInteger)count;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLPolyline.h b/platform/darwin/include/MGLPolyline.h
new file mode 100644
index 0000000000..c28299c7e0
--- /dev/null
+++ b/platform/darwin/include/MGLPolyline.h
@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+#import "MGLMultiPoint.h"
+#import "MGLOverlay.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The `MGLPolyline` class represents a shape consisting of one or more points that define connecting line segments. The points are connected end-to-end in the order they are provided. The first and last points are not connected to each other. */
+@interface MGLPolyline : MGLMultiPoint <MGLOverlay>
+
+/**
+ Creates and returns an `MGLPolyline` object from the specified set of coordinates.
+ 
+ @param coords The array of coordinates defining the shape. The data in this array is copied to the new object.
+ @param count The number of items in the `coords` array.
+ @return A new polyline object.
+ */
++ (instancetype)polylineWithCoordinates:(CLLocationCoordinate2D *)coords
+                                  count:(NSUInteger)count;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLShape.h b/platform/darwin/include/MGLShape.h
new file mode 100644
index 0000000000..c1b84816f2
--- /dev/null
+++ b/platform/darwin/include/MGLShape.h
@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+
+#import "MGLAnnotation.h"
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The `MGLShape` class is an abstract class that defines the basic properties for all shape-based annotation objects. This class must be subclassed and cannot be used as is. Subclasses are responsible for defining the geometry of the shape and providing an appropriate value for the coordinate property inherited from the `MGLAnnotation` protocol. */
+@interface MGLShape : NSObject <MGLAnnotation>
+
+/** The title of the shape annotation. The default value of this property is `nil`. */
+@property (nonatomic, copy, nullable) NSString *title;
+
+/** The subtitle of the shape annotation. The default value of this property is `nil`. */
+@property (nonatomic, copy, nullable) NSString *subtitle;
+
+#if !TARGET_OS_IPHONE
+
+/** The tooltip of the shape annotation. The default value of this property is `nil`. */
+@property (nonatomic, copy, nullable) NSString *toolTip;
+
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLStyle.h b/platform/darwin/include/MGLStyle.h
new file mode 100644
index 0000000000..e5b2de877c
--- /dev/null
+++ b/platform/darwin/include/MGLStyle.h
@@ -0,0 +1,56 @@
+#import <Foundation/Foundation.h>
+
+#import "MGLTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** A collection of convenience methods for creating style URLs of default styles provided by Mapbox. These instances of NSURL are cached. */
+@interface MGLStyle : NSObject
+
+/**
+ Returns the Streets style URL.
+ 
+ Mapbox Streets is a complete base map, perfect for incorporating your own data.
+ */
++ (NSURL *)streetsStyleURL;
+
+/**
+ Returns the Emerald style URL.
+ 
+ Emerald is a versatile style with emphasis on road networks and public transportation.
+ */
++ (NSURL *)emeraldStyleURL;
+
+/**
+ Returns the Light style URL.
+ 
+ Light is a subtle, light-colored backdrop for data visualizations.
+ */
++ (NSURL *)lightStyleURL;
+
+/**
+ Returns the Dark style URL.
+ 
+ Dark is a subtle, dark-colored backdrop for data visualizations.
+ */
++ (NSURL *)darkStyleURL;
+
+/**
+ Returns the Satellite style URL.
+ 
+ Mapbox Satellite is a beautiful global satellite and aerial imagery layer.
+ */
++ (NSURL *)satelliteStyleURL;
+
+/**
+ Returns the Hybrid style URL.
+ 
+ Hybrid combines the global satellite and aerial imagery of Mapbox Satellite with unobtrusive labels.
+ */
++ (NSURL *)hybridStyleURL;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/include/MGLTypes.h b/platform/darwin/include/MGLTypes.h
new file mode 100644
index 0000000000..c107055dbb
--- /dev/null
+++ b/platform/darwin/include/MGLTypes.h
@@ -0,0 +1,53 @@
+#import <Foundation/Foundation.h>
+
+#pragma once
+
+#if !__has_feature(nullability)
+    #define NS_ASSUME_NONNULL_BEGIN
+    #define NS_ASSUME_NONNULL_END
+    #define nullable
+    #define nonnull
+    #define null_resettable
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** Indicates an error occurred in the Mapbox SDK. */
+extern NSString * const MGLErrorDomain;
+
+/** The mode used to track the user location on the map. */
+typedef NS_ENUM(NSUInteger, MGLUserTrackingMode) {
+    /** The map does not follow the user location. */
+    MGLUserTrackingModeNone              = 0,
+    /** The map follows the user location. */
+    MGLUserTrackingModeFollow,
+    /** The map follows the user location and rotates when the heading changes. */
+    MGLUserTrackingModeFollowWithHeading,
+    /** The map follows the user location and rotates when the course changes. */
+    MGLUserTrackingModeFollowWithCourse,
+};
+
+NS_ASSUME_NONNULL_END
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wvariadic-macros"
+    #ifndef NS_ARRAY_OF
+        // Foundation collection classes adopted lightweight generics in iOS 9.0 and OS X 10.11 SDKs.
+        #if __has_feature(objc_generics) && (__IPHONE_OS_VERSION_MAX_ALLOWED >= 90000 || __MAC_OS_X_VERSION_MAX_ALLOWED >= 101100)
+            /** Inserts a type specifier for a pointer to a lightweight generic with the given collection and object classes. Use a `*` for any non-`id` object classes but no `*` for the collection class. */
+            #define NS_ARRAY_OF(ObjectClass...)                 NSArray <ObjectClass>
+            #define NS_MUTABLE_ARRAY_OF(ObjectClass...)         NSMutableArray <ObjectClass>
+            #define NS_SET_OF(ObjectClass...)                   NSSet <ObjectClass>
+            #define NS_MUTABLE_SET_OF(ObjectClass...)           NSMutableSet <ObjectClass>
+            #define NS_DICTIONARY_OF(ObjectClass...)            NSDictionary <ObjectClass>
+            #define NS_MUTABLE_DICTIONARY_OF(ObjectClass...)    NSMutableDictionary <ObjectClass>
+        #else
+            #define NS_ARRAY_OF(ObjectClass...)                 NSArray
+            #define NS_MUTABLE_ARRAY_OF(ObjectClass...)         NSMutableArray
+            #define NS_SET_OF(ObjectClass...)                   NSSet
+            #define NS_MUTABLE_SET_OF(ObjectClass...)           NSMutableSet
+            #define NS_DICTIONARY_OF(ObjectClass...)            NSDictionary
+            #define NS_MUTABLE_DICTIONARY_OF(ObjectClass...)    NSMutableDictionary
+        #endif
+    #endif
+#pragma clang diagnostic pop