ProMotion-mapbox 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a6c7b1a09e8296b378386a2508ff9803ffee0a3
+  data.tar.gz: 4f9f1e7093bb2981aeffe516cb783f033cfab280
+SHA512:
+  metadata.gz: 16b2612226da961d263dc65d83f1f060238cb18d646c9fcd992961d5516534f13ab7e3c549569c23b469777ebf7bc22587835077f55eea0776bbbe43dcf11af2
+  data.tar.gz: ab5d5c5075abb292a91a3fb85650136fd9c2893fc017f9dfb2094120fedfe16e5a1fe95aa1d1ee6663d22fe361dc386980db74c6faf087a96f859ef06385e0c7

data/README.md

@@ -0,0 +1,376 @@
+# ProMotion-mapbox
+
+[![Gem Version](https://badge.fury.io/rb/ProMotion-mapbox.svg)](http://badge.fury.io/rb/ProMotion-mapbox)
+
+ProMotion-mapbox provides a PM::MapScreen, forked from the
+popular RubyMotion gem [ProMotion-map](https://github.com/clearsightstudio/ProMotion-map).
+
+## Installation
+
+```ruby
+gem 'ProMotion-mapbox'
+```
+```ruby
+rake pod:install
+```
+
+
+## Usage
+
+Easily create a map screen, complete with annotations.
+
+*Has all the methods of PM::Screen*
+
+```ruby
+class MyMapScreen < PM::MapScreen
+    mapbox_setup access_token: "YOU_MAPBOX_ACCESS_TOKEN",
+    tile_source: "mylogin.map"
+
+  title "My Map"
+  start_position latitude: 35.090648651123, longitude: -82.965972900391, radius: 4
+  tap_to_add
+
+  def annotation_data
+    [{
+      longitude: -82.965972900391,
+      latitude: 35.090648651123,
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest",
+      action: :show_forest,
+      pin_color: :green
+    },{
+      longitude: -82.966093558105,
+      latitude: 35.092520895652,
+      title: "Turtleback Falls",
+      subtitle: "Nantahala National Forest",
+      action: :show_forest,
+      pin_color: :purple]
+    },{
+      longitude: -82.95916,
+      latitude: 35.07496,
+      title: "Windy Falls",
+      action: :show_forest
+    },{
+      longitude: -82.943031505056,
+      latitude: 35.102516828489,
+      title: "Upper Bearwallow Falls",
+      subtitle: "Gorges State Park",
+      action: :show_forest
+    },{
+      longitude: -82.956244328014,
+      latitude: 35.085548421623,
+      title: "Stairway Falls",
+      subtitle: "Gorges State Park",
+      your_param: "CustomWhatever",
+      action: :show_forest
+    }, {
+      coordinate: CLLocationCoordinate2DMake(35.090648651123, -82.965972900391)
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest",
+      image: UIImage.imageNamed("custom-pin"),
+      action: :show_forest
+    }]
+  end
+
+  def show_forest
+    selected = selected_annotations.first
+    # Do something with the selected annotation.
+  end
+end
+```
+
+Here's a neat way to zoom into a specific marker in an animated fashion and then select the marker:
+
+```ruby
+def zoom_to_marker(marker)
+  set_region region(coordinate: marker.coordinate, radius: 5) # Radius are specified in nautical miles.
+  select_annotation marker
+end
+```
+
+---
+
+### Methods
+
+#### annotation_data
+
+Method that is called to get the map's annotation data and build the map. If you do not want any annotations, simply return an empty array.
+
+All possible properties:
+
+```ruby
+{
+    # REQUIRED -or- use :coordinate
+    longitude: -82.956244328014,
+    latitude: 35.085548421623,
+
+    # REQUIRED -or- use :longitude & :latitude
+    coordinate: CLLocationCoordinate2DMake(35.085548421623, -82.956244328014)
+
+    title: "Stairway Falls", # REQUIRED
+    subtitle: "Gorges State Park",
+    image: "my_custom_image",
+    pin_color: :red, # Defaults to :red. Other options are :green or :purple or any UIColor
+    left_accessory: my_button,
+    right_accessory: my_other_button,
+    action: :my_action, # Overrides :right_accessory
+    action_button_type: UIButtonTypeContactAdd # Defaults to UIButtonTypeDetailDisclosure
+}
+```
+
+You may pass whatever properties you want in the annotation hash, but (`:longitude` && `:latitude` || `:coordinate`), and `:title` are required.
+
+Use `:image` to specify a custom image. Pass in a string to conserve memory and it will be converted using `UIImage.imageNamed(your_string)`. If you pass in a `UIImage`, we'll use that, but keep in mind that there will be another unnecessary copy of the UIImage in memory.
+
+Use `:left_accessory` and `:right_accessory` to specify a custom accessory, like a button.
+
+You can access annotation data you've arbitrarily stored in the hash by calling `annotation_instance.params[:your_param]`.
+
+The `:action` parameter specifies a method that should be run when the detail button is tapped on the annotation. It automatically adds a `UIButtonTypeDetailDisclosure` button to the `:left_accessory`. In your method you can find out which annotation's accessory was tapped by calling `selected_annotations.first`.
+
+#### update_annotation_data
+
+Forces a reload of all the annotations
+
+#### annotations
+
+Returns an array of all the annotations.
+
+#### center
+
+Returns a `CLLocation2D` instance with the center coordinates of the map.
+
+#### center=({latitude: Float, longitude: Float, animated: Boolean})
+
+Sets the center of the map. `animated` property defaults to `true`.
+
+#### show_user_location
+
+Shows the user's location on the map. Must be called in the view initialization sequence on `will_appear` or _after_.
+
+#### look_up_location(CLLocation) { |placemark, error| }
+
+This method takes a CLLocation object and will return one to many CLPlacemark to represent nearby data.
+
+##### iOS 8 Location Requirements
+
+iOS 8 introduced stricter location services requirements. You are now required to add a few key/value pairs to the `Info.plist`. Add these two lines to your `Rakefile` (with your descriptions, obviously):
+
+```ruby
+app.info_plist['NSLocationAlwaysUsageDescription'] = 'Description'
+app.info_plist['NSLocationWhenInUseUsageDescription'] = 'Description'
+```
+
+*Note: you need both keys to use `get_once`, so it's probably best to just include both no matter what.* See [Apple's documentation](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW18) on iOS 8 location services requirements for more information.
+
+#### hide_user_location
+
+Hides the user's location on the map.
+
+#### showing_user_location?
+
+Returns a `Boolean` of whether or not the map view is currently showing the user's location.
+
+#### user_location
+
+Returns a `CLLocation2D` object of the user's location or `nil` if the user location is not being tracked
+
+#### zoom_to_user(radius = 0.05, animated=true)
+
+Zooms to the user's location. If the user's location is not currently being shown on the map, it will show it first. `radius` is the distance in nautical miles from the center point (user location) to the corners of a virtual bounding box.
+
+#### select_annotation(annotation, animated=true)
+
+Selects a single annotation.
+
+#### select_annotation_at(annotation_index, animated=true)
+
+Selects a single annotation using the annotation at the index of your `annotation_data` array.
+
+#### selected_annotation
+
+Returns the annotation that is selected. If no annotation is selected, returns `nil`.
+
+#### deselect_annotation(animated=false)
+
+Deselects any selected annotation.
+
+#### add_annotation(annotation)
+
+Adds a new annotation to the map. Refer to `annotation_data` (above) for hash properties.
+
+#### add_annotations(annotations)
+
+Adds more than one annotation at a time to the map.
+
+#### clear_annotations
+
+Removes all annotations from the `MapScreen`.
+
+#### zoom_to_fit_annotations({animated:true, include_user:false})
+
+Changes the zoom and center point of the `MapScreen` to fit all the annotations. Passing `include_user` as `true` will cause the zoom to not only include the annotations from `annotation_data` but also the user pin in the zoom region calculation.
+
+#### set_region(region, animated=true)
+
+Sets the region of the `MapScreen`. `region` should be an instance of `MKCoordinateRegion`.
+
+#### region(center_location,radius=10)
+
+Mapbox API doesn't have the concept of a region. Instead, we can zoom to a virtual bounding box defined by its Sourthwest and Northeast
+corners.
+The ```region``` methods takes a ```center_location``` and a radius. The distance from the center to the corners (and thus the zoom level) will be the ```radius``` times 1820 meters (1 Nautical mile)
+
+```ruby
+my_region = region({
+  CLLocationCoordinate2D.new(35.0906,-82.965),
+  radius: 11
+})
+```
+
+---
+
+### Class Methods
+
+#### start_position(latitude: Float, longitude: Float, radius: Float)
+
+Class method to set the initial starting position of the `MapScreen`.
+
+```ruby
+class MyMapScreen < PM::MapScreen
+  start_position latitude: 36.10, longitude: -80.26, radius: 4
+end
+```
+
+`radius` is the zoom level of the map in miles (default: 10).
+
+#### tap_to_add(length: Float, target: Object, action: Selector, annotation: Hash)
+
+Lets a user long press the map to drop an annotation where they pressed.
+
+##### Default values:
+
+You can override any of these values. The `annotation` parameter can take any options specified in the annotation documentation above except `:latitude`, `:longitude`, and `:coordinate`.
+
+```ruby
+length: 2.0,
+target: self,
+action: "gesture_drop_pin:",
+annotation: {
+  title: "Dropped Pin",
+  animates_drop: true
+}
+```
+
+##### Notifications
+
+This feature posts two different `NSNotificationCenter` notifications:
+
+**ProMotionMapWillAddPin:** Fired the moment the long press gesture is recognized, before the pin is added.
+
+**ProMotionMapAddedPin:** Fired after the pin has been added to the map.
+
+##### Example:
+
+```ruby
+# Simple Example
+class MyMapScreen < PM::MapScreen
+  title "My Map Screen"
+  tap_to_add length: 1.5
+  def annotations
+    []
+  end
+end
+```
+
+```ruby
+# A More Complex Example
+class MyMapScreen < PM::MapScreen
+  title "My Map Screen"
+  tap_to_add length: 1.5, annotation: {animates_drop: true, title: "A Cool New Pin"}
+  def annotations
+    []
+  end
+
+  def will_appear
+    NSNotificationCenter.defaultCenter.addObserver(self, selector:"pin_adding:") , name:"ProMotionMapWillAddPin", object:nil)
+    NSNotificationCenter.defaultCenter.addObserver(self, selector:"pin_added:") , name:"ProMotionMapAddedPin", object:nil)
+  end
+
+  def will_disappear
+    NSNotificationCenter.defaultCenter.removeObserver(self)
+  end
+
+  def pin_adding(notification)
+    # We only want one pin on the map at a time
+    clear_annotations
+  end
+
+  def pin_added(notification)
+    # Once the pin is dropped we want to select it
+    select_annotation_at(0)
+  end
+end
+```
+
+---
+
+### Delegate callbacks
+
+These methods (if implemented in your `MapScreen`) will be called when the corresponding `MKMapViewDelegate` method is invoked:
+
+```ruby
+def will_change_region(animated)
+  # Do something when the region will change
+  # The animated parameter is optional so you can also define it is simply:
+  # def will_change_region
+  # end
+end
+
+def on_change_region(animated)
+  # Do something when the region changed
+  # The animated parameter is optional so you can also define it is simply:
+  # def on_change_region
+  # end
+end
+```
+
+---
+
+### CocoaTouch Property Convenience Methods
+
+`MKMapView` contains multiple property setters and getters that can be accessed in a more ruby-like syntax:
+
+```ruby
+type # Returns a MKMapType
+type = (MKMapType)new_type
+
+zoom_enabled?
+zoom_enabled = (bool)enabled
+
+scroll_enabled?
+scroll_enabled = (bool)enabled
+
+pitch_enabled?
+pitch_enabled = (bool)enabled
+
+rotate_enabled?
+rotate_enabled = (bool)enabled
+```
+
+---
+
+### Accessors
+
+#### `map` or `mapview`
+
+Reference to the created RMMapView.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Make some specs pass
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/lib/ProMotion-mapbox.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+unless defined?(Motion::Project::Config)
+  raise "ProMotion-mapbox must be required within a RubyMotion project."
+end
+
+require 'motion-cocoapods'
+
+Motion::Project::App.setup do |app|
+  lib_dir_path = File.dirname(File.expand_path(__FILE__))
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_annotation.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_module.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen.rb")
+
+  app.frameworks += %w(CoreLocation)
+
+  app.pods do
+    pod "Mapbox-iOS-SDK"
+  end
+
+end

data/lib/ProMotion/map/map_screen.rb

@@ -0,0 +1,6 @@
+module ProMotion
+  class MapScreen < ViewController
+    include ProMotion::ScreenModule
+    include ProMotion::MapScreenModule
+  end
+end

data/lib/ProMotion/map/map_screen_annotation.rb

@@ -0,0 +1,74 @@
+module ProMotion
+  class MapScreenAnnotation < RMAnnotation
+    attr_reader :params
+
+    def initialize(params = {},map_view)
+      @params = params
+      @map_view = map_view
+      set_defaults
+
+      if @params[:coordinate]
+        @params[:latitude] = @params[:coordinate].latitude
+        @params[:longitude] = @params[:coordinate].longitude
+        @coordinate = @params[:coordinate]
+        initWithMapView(map_view, coordinate: @coordinate, andTitle: @params[:title])
+      elsif @params[:latitude] && @params[:longitude]
+        @coordinate = CLLocationCoordinate2D.new(@params[:latitude], @params[:longitude])
+        initWithMapView(map_view, coordinate: @coordinate, andTitle: @params[:title])
+      else
+        PM.logger.error("You are required to specify :latitude and :longitude or :coordinate for annotations.")
+        nil
+      end
+    end
+    
+    def set_defaults
+      @params = {
+        title: "Title",
+        pin_color: :red,
+        identifier: "Annotation-#{@params[:pin_color]}-#{@params[:image]}",
+        show_callout: true,
+        animates_drop: false,
+        maki_icon: nil,
+      }.merge(@params)
+    end
+
+    def title
+      @params[:title]
+    end
+
+    def subtitle
+      @params[:subtitle] ||= nil
+    end
+
+    def coordinate
+      @coordinate
+    end
+    
+    def pin_color
+      @params[:pin_color]
+    end
+
+    def cllocation
+      CLLocation.alloc.initWithLatitude(@params[:latitude], longitude:@params[:longitude])
+    end
+
+    def setCoordinate(new_coordinate)
+      super
+      if new_coordinate.is_a? Hash
+        @coordinate = CLLocationCoordinate2D.new(new_coordinate[:latitude], new_coordinate[:longitude])
+      else
+        @coordinate = new_coordinate
+      end
+    end
+
+    def method_missing(meth, *args)
+      if @params[meth.to_sym]
+        @params[meth.to_sym]
+      else
+        PM.logger.warn "The annotation parameter \"#{meth}\" does not exist on this pin."
+        nil
+      end
+    end
+
+  end
+end

data/lib/ProMotion/map/map_screen_module.rb

@@ -0,0 +1,448 @@
+module ProMotion
+  module MapScreenModule
+
+    PIN_COLORS = {
+      red: UIColor.redColor,
+      green: UIColor.greenColor,
+      purple: UIColor.purpleColor
+    }
+        
+    def screen_setup
+      mapbox_setup
+      self.view = nil
+      self.view = RMMapView.alloc.initWithFrame(self.view.bounds, andTilesource:@tileSource)
+      self.view.delegate = self
+
+      check_annotation_data
+      @promotion_annotation_data = []
+      set_up_tap_to_add
+    end
+    
+    def mapbox_setup
+      if self.class.respond_to?(:get_mapbox_setup) && self.class.get_mapbox_setup
+        setup_params = self.class.get_mapbox_setup_params
+      else
+        PM.logger.error "Missing Mapbox setup data."
+      end
+      RMConfiguration.sharedInstance.setAccessToken(setup_params[:access_token])
+      @tileSource = RMMapboxSource.alloc.initWithMapID(setup_params[:tile_source])
+    end
+    
+    def view_will_appear(animated)
+      super
+      update_annotation_data
+    end
+
+    def view_did_appear(animated)
+      super
+      set_up_start_position
+    end
+    
+    def check_annotation_data
+      PM.logger.error "Missing #annotation_data method in MapScreen #{self.class.to_s}." unless self.respond_to?(:annotation_data)
+    end
+
+    def update_annotation_data
+      clear_annotations
+      add_annotations annotation_data
+    end
+    
+    def map
+      self.view
+    end
+    alias_method :mapview, :map
+
+    def center
+      self.view.centerCoordinate
+    end
+
+    def center=(params={})
+      PM.logger.error "Missing #:latitude property in call to #center=." unless params[:latitude]
+      PM.logger.error "Missing #:longitude property in call to #center=." unless params[:longitude]
+      params[:animated] ||= true
+
+      # Set the new region
+      self.view.setCenterCoordinate(
+        CLLocationCoordinate2D.new(params[:latitude], params[:longitude]),
+        animated:params[:animated]
+      )
+    end
+
+    def show_user_location
+      if location_manager.respondsToSelector('requestWhenInUseAuthorization')
+        location_manager.requestWhenInUseAuthorization
+      end
+
+      set_show_user_location true
+    end
+
+    def hide_user_location
+      set_show_user_location false
+    end
+
+    def set_show_user_location(show)
+      self.view.showsUserLocation = show
+    end
+
+    def showing_user_location?
+      self.view.showsUserLocation
+    end
+
+    def user_location
+      user_annotation.nil? ? nil : user_annotation.coordinate
+    end
+
+    def user_annotation
+      self.view.userLocation.nil? ? nil : self.view.userLocation.location
+    end
+
+    def zoom_to_user(radius = 0.05, animated=true)
+      show_user_location unless showing_user_location?
+      set_region(create_region(user_location,radius), animated)
+    end
+
+    def annotations
+      @promotion_annotation_data
+    end
+
+    def select_annotation(annotation, animated=true)
+      self.view.selectAnnotation(annotation, animated:animated)
+    end
+
+    def select_annotation_at(annotation_index, animated=true)
+      select_annotation(annotations[annotation_index], animated:animated)
+    end
+
+    def selected_annotation
+      self.view.selectedAnnotation
+    end
+
+    def deselect_annotation(animated=false)
+      unless selected_annotation.nil?
+        self.view.deselectAnnotation(selected_annotation, animated:animated)
+      end
+    end
+
+    def add_annotation(annotation)
+      @promotion_annotation_data << MapScreenAnnotation.new(annotation,self.view)
+      self.view.addAnnotation @promotion_annotation_data.last
+    end
+
+    def add_annotations(annotations)
+      @promotion_annotation_data = Array(annotations).map{|a| MapScreenAnnotation.new(a,self.view)}
+      self.view.addAnnotations @promotion_annotation_data
+    end
+
+    def clear_annotations
+      @promotion_annotation_data.each do |a|
+        self.view.removeAnnotation(a)
+      end
+      @promotion_annotation_data = []
+    end
+
+    def annotation_view(map_view, annotation)
+      return if annotation.is_a? RMUserLocation
+
+      params = annotation.params
+
+      identifier = params[:identifier]
+      # Set the pin properties
+      if params[:image]
+        view = RMMarker.alloc.initWithUIImage(params[:image])
+      else
+        pinColor = (PIN_COLORS[params[:pin_color]] || params[:pin_color])
+        view = RMMarker.alloc.initWithMapboxMarkerImage(params[:maki_icon], tintColor: pinColor)
+      end
+      view.annotation = annotation
+      view.canShowCallout = params[:show_callout] if view.respond_to?("canShowCallout=")
+
+      if params[:left_accessory]
+        view.leftCalloutAccessoryView = params[:left_accessory]
+      end
+      if params[:right_accessory]
+        view.rightCalloutAccessoryView = params[:right_accessory]
+      end
+
+      if params[:action]
+        button_type = params[:action_button_type] || UIButtonTypeDetailDisclosure
+
+        action_button = UIButton.buttonWithType(button_type)
+        action_button.addTarget(self, action: params[:action], forControlEvents:UIControlEventTouchUpInside)
+
+        view.rightCalloutAccessoryView = action_button
+      end
+      view
+    end
+
+    def set_start_position(params={})
+      params = {
+        latitude: 37.331789,
+        longitude: -122.029620,
+        radius: 10
+      }.merge(params)
+      initialLocation = CLLocationCoordinate2D.new(params[:latitude], params[:longitude])
+      region = create_region(initialLocation,params[:radius])
+      set_region(region, animated:false)
+    end
+
+    def set_up_start_position
+      if self.class.respond_to?(:get_start_position) && self.class.get_start_position
+        self.set_start_position self.class.get_start_position_params
+      end
+    end
+
+    def set_tap_to_add(params={})
+      params = {
+        length: 2.0,
+        target: self,
+        action: "gesture_drop_pin:",
+        annotation: {
+          title: "Dropped Pin",
+          animates_drop: true
+        }
+      }.merge(params)
+      @tap_to_add_annotation_params = params[:annotation]
+
+      lpgr = UILongPressGestureRecognizer.alloc.initWithTarget(params[:target], action:params[:action])
+      lpgr.minimumPressDuration = params[:length]
+      self.view.addGestureRecognizer(lpgr)
+    end
+
+    def gesture_drop_pin(gesture_recognizer)
+      if gesture_recognizer.state == UIGestureRecognizerStateBegan
+        NSNotificationCenter.defaultCenter.postNotificationName("ProMotionMapWillAddPin", object:nil)
+        touch_point = gesture_recognizer.locationInView(self.view)
+        touch_map_coordinate = self.view.convertPoint(touch_point, toCoordinateFromView:self.view)
+
+        add_annotation({
+          coordinate: touch_map_coordinate
+        }.merge(@tap_to_add_annotation_params))
+        NSNotificationCenter.defaultCenter.postNotificationName("ProMotionMapAddedPin", object:@promotion_annotation_data.last)
+      end
+    end
+
+    def set_up_tap_to_add
+      if self.class.respond_to?(:get_tap_to_add) && self.class.get_tap_to_add
+        self.set_tap_to_add self.class.get_tap_to_add_params
+      end
+    end
+
+    # TODO: Why is this so complex?
+    def zoom_to_fit_annotations(args={})
+      # Preserve backwards compatibility
+      args = {animated: args} if args == true || args == false
+      args = {animated: true, include_user: false}.merge(args)
+
+      ann = args[:include_user] ? (annotations + [user_annotation]).compact : annotations
+
+      #Don't attempt the rezoom of there are no pins
+      return if ann.count == 0
+
+      #Set some crazy boundaries
+      topLeft = CLLocationCoordinate2D.new(-90, 180)
+      bottomRight = CLLocationCoordinate2D.new(90, -180)
+
+      #Find the bounds of the pins
+      ann.each do |a|
+        topLeft.longitude = [topLeft.longitude, a.coordinate.longitude].min
+        topLeft.latitude = [topLeft.latitude, a.coordinate.latitude].max
+        bottomRight.longitude = [bottomRight.longitude, a.coordinate.longitude].max
+        bottomRight.latitude = [bottomRight.latitude, a.coordinate.latitude].min
+      end
+
+      #Find the bounds of all the pins and set the map_view
+      coord = CLLocationCoordinate2D.new(
+        topLeft.latitude - (topLeft.latitude - bottomRight.latitude) * 0.5,
+        topLeft.longitude + (bottomRight.longitude - topLeft.longitude) * 0.5
+      )
+
+      # Add some padding to the edges
+      span = MKCoordinateSpanMake(
+        ((topLeft.latitude - bottomRight.latitude) * 1.075).abs,
+        ((bottomRight.longitude - topLeft.longitude) * 1.075).abs
+      )
+
+      region = MKCoordinateRegionMake(coord, span)
+      fits = self.view.regionThatFits(region)
+
+      set_region(fits, animated: args[:animated])
+    end
+
+    def set_region(region, animated=true)
+      self.view.zoomWithLatitudeLongitudeBoundsSouthWest(
+        region[:southWest],
+        northEast: region[:northEast], 
+        animated: animated
+      )
+    end
+        
+    def deg_to_rad(angle)
+      angle*Math::PI/180
+    end
+
+    def rad_to_deg(angle)
+      angle*180/Math::PI
+    end
+
+    # Input coordinates and bearing in decimal degrees, distance in kilometers
+    def point_from_location_bearing_and_distance(initialLocation, bearing, distance)
+      distance = distance / 6371.01 # Convert to angular radians dividing by the Earth radius
+      bearing = deg_to_rad(bearing)
+      input_latitude = deg_to_rad(initialLocation.latitude)
+      input_longitude = deg_to_rad(initialLocation.longitude)
+
+      output_latitude = Math.asin( 
+                          Math.sin(input_latitude) * Math.cos(distance) + 
+                          Math.cos(input_latitude) * Math.sin(distance) * 
+                          Math.cos(bearing)
+                        )
+      
+      dlon = input_longitude + Math.atan2(
+                                Math.sin(bearing) * Math.sin(distance) * 
+                                Math.cos(input_longitude), Math.cos(distance) - 
+                                Math.sin(input_longitude) * Math.sin(output_latitude)
+                              )
+      
+      output_longitude = (dlon + 3*Math::PI) % (2*Math::PI) - Math::PI  
+      CLLocationCoordinate2DMake(rad_to_deg(output_latitude), rad_to_deg(output_longitude))
+    end
+    
+    def create_region(initialLocation,radius=10)
+      return nil unless initialLocation.is_a? CLLocationCoordinate2D
+      radius = radius * 1.820 # Meters equivalent to 1 Nautical Mile
+      southWest = self.point_from_location_bearing_and_distance(initialLocation,225, radius)
+      northEast = self.point_from_location_bearing_and_distance(initialLocation,45, radius)
+      {:southWest => southWest, :northEast => northEast}
+    end
+    alias_method :region, :create_region
+    
+    def look_up_address(args={}, &callback)
+      args[:address] = args if args.is_a? String # Assume if a string is passed that they want an address
+
+      geocoder = CLGeocoder.new
+      return geocoder.geocodeAddressDictionary(args[:address], completionHandler: callback) if args[:address].is_a?(Hash)
+      return geocoder.geocodeAddressString(args[:address].to_s, completionHandler: callback) unless args[:region]
+      return geocoder.geocodeAddressString(args[:address].to_s, inRegion:args[:region].to_s, completionHandler: callback) if args[:region]
+    end
+
+    def look_up_location(location, &callback)
+      location = CLLocation.alloc.initWithLatitude(location.latitude, longitude:location.longitude) if location.is_a?(CLLocationCoordinate2D)
+
+      if location.kind_of?(CLLocation)
+        geocoder = CLGeocoder.new
+        geocoder.reverseGeocodeLocation(location, completionHandler: callback)
+      else
+        PM.logger.info("You're trying to reverse geocode something that isn't a CLLocation")
+        callback.call nil, nil
+      end
+    end
+
+    ########## Mapbox methods #################
+    def mapView(map_view, layerForAnnotation: annotation)
+      annotation_view(map_view, annotation)
+    end
+
+    ########## Cocoa touch methods #################
+    def mapView(map_view, didUpdateUserLocation:userLocation)
+      if self.respond_to?(:on_user_location)
+        on_user_location(userLocation)
+      else
+        PM.logger.info "You're tracking the user's location but have not implemented the #on_user_location(location) method in MapScreen #{self.class.to_s}."
+      end
+    end
+
+    def mapView(map_view, regionWillChangeAnimated:animated)
+      if self.respond_to?("will_change_region:")
+        will_change_region(animated)
+      elsif self.respond_to?(:will_change_region)
+        will_change_region
+      end
+    end
+
+    def mapView(map_view, regionDidChangeAnimated:animated)
+      if self.respond_to?("on_change_region:")
+        on_change_region(animated)
+      elsif self.respond_to?(:on_change_region)
+        on_change_region
+      end
+    end
+
+    ########## Cocoa touch Ruby counterparts #################
+
+    def deceleration_mode
+      map.decelerationMode
+    end
+
+    def deceleration_mode=(mode)
+      map.decelerationMode = mode
+    end
+
+    %w(dragging bouncing clustering).each do |meth|
+      define_method("#{meth}_enabled?") do
+        map.send("#{meth}Enabled")
+      end
+
+      define_method("#{meth}_enabled=") do |argument|
+        map.send("#{meth}Enabled=", argument)
+      end
+    end
+
+    module MapClassMethods
+      # Start Position
+      def start_position(params={})
+        @start_position_params = params
+        @start_position = true
+      end
+
+      def get_start_position_params
+        @start_position_params ||= nil
+      end
+
+      def get_start_position
+        @start_position ||= false
+      end
+
+      # Tap to drop pin
+      def tap_to_add(params={})
+        @tap_to_add_params = params
+        @tap_to_add = true
+      end
+
+      def get_tap_to_add_params
+        @tap_to_add_params ||= nil
+      end
+
+      def get_tap_to_add
+        @tap_to_add ||= false
+      end
+      
+      # Mapbox setup
+      def mapbox_setup(params={})
+        @mapbox_setup_params = params
+        @mapbox_setup = true
+      end
+      
+      def get_mapbox_setup_params
+        @mapbox_setup_params ||= nil
+      end
+      
+      def get_mapbox_setup
+        @mapbox_setup ||= false
+      end
+      
+
+    end
+    def self.included(base)
+      base.extend(MapClassMethods)
+    end
+
+    private
+
+    def location_manager
+      @location_manager ||= CLLocationManager.alloc.init
+      @location_manager.delegate ||= self
+      @location_manager
+    end
+
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: ProMotion-mapbox
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Diogo Andre
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ProMotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: motion-stump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: motion-redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds PM::MapScreen support to ProMotion, using Mapbox as map provider.
+email:
+- diogo@regattapix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ProMotion/map/map_screen.rb
+- lib/ProMotion/map/map_screen_annotation.rb
+- lib/ProMotion/map/map_screen_module.rb
+- lib/ProMotion-mapbox.rb
+homepage: https://github.com/diogoandre/ProMotion-mapbox
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Adds PM::MapScreen support to ProMotion, using Mapbox as map provider. Forked
+  from Promotion-map
+test_files: []