コード例 #1
0
 public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
 {
     if (overlay is MKCircle)
     {
         if (circleRenderer == null)
         {
             circleRenderer           = new MKCircleRenderer(overlay as MKCircle);
             circleRenderer.FillColor = UIColor.Purple;
             circleRenderer.Alpha     = 0.5f;
         }
         return(circleRenderer);
     }
     else if (overlay is MKPolygon)
     {
         if (polyRenderer == null)
         {
             polyRenderer           = new MKPolygonRenderer(overlay as MKPolygon);
             polyRenderer.FillColor = UIColor.Green;
             polyRenderer.Alpha     = 0.5f;
         }
         return(polyRenderer);
     }
     else
     {
         Debug.WriteLine("OverlayRenderer() - Unknown overlay type!");
         return(null);
     }
 }
コード例 #2
0
 MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlay)
 {
     if (!isCircle)
     {
         if (polylineRenderer == null)
         {
             polylineRenderer             = new MKPolylineRenderer(overlay as MKPolyline);
             polylineRenderer.FillColor   = UIColor.Blue;
             polylineRenderer.StrokeColor = UIColor.Red;
             polylineRenderer.LineWidth   = 3;
             polylineRenderer.Alpha       = 0.4f;
         }
         isLoaded = true;
         return(polylineRenderer);
     }
     if (isCircle)
     {
         if (circleRenderer == null)
         {
             circleRenderer           = new MKCircleRenderer(overlay as MKCircle);
             circleRenderer.FillColor = UIColor.Red;
             circleRenderer.Alpha     = 0.4f;
         }
         isLoaded = true;
         return(circleRenderer);
     }
     return(polylineRenderer);
 }
コード例 #3
0
            public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlayWrapper)
            {
                var type    = overlayWrapper.GetType();
                var overlay = overlayWrapper as IMKOverlay;

                if (overlay is MKPolyline || type == typeof(MKPolyline))
                {
                    if (polylineRenderer == null)
                    {
                        polylineRenderer = new MKPolylineRenderer(overlay as MKPolyline);
                        //polylineRenderer.FillColor = UIColor.Blue;
                        polylineRenderer.StrokeColor = UIColor.Red;
                        polylineRenderer.LineWidth   = 5;
                        isLoaded = true;
                    }
                    return(polylineRenderer);
                }
                else if (overlay is MKCircle)
                {
                    if (circleRenderer == null)
                    {
                        circleRenderer           = new MKCircleRenderer(overlay as MKCircle);
                        circleRenderer.FillColor = UIColor.Red;
                        circleRenderer.Alpha     = 0.2f;
                        isLoaded = true;
                    }
                    return(circleRenderer);
                }
                return(base.OverlayRenderer(mapView, overlayWrapper));
            }
コード例 #4
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            Title = "Pyramids of Giza";

            mapView = new MKMapView(View.Bounds);
            mapView.AutoresizingMask = UIViewAutoresizing.FlexibleDimensions;
            View.AddSubview(mapView);

            var coords = new CLLocationCoordinate2D(29.976111, 31.132778);             // pyramids of giza, egypt
            var span   = new MKCoordinateSpan(MilesToLatitudeDegrees(.75), MilesToLongitudeDegrees(.75, coords.Latitude));

            // set the coords and zoom on the map
            mapView.MapType = MKMapType.Satellite;
            mapView.Region  = new MKCoordinateRegion(coords, span);

            mapView.OverlayRenderer = (m, o) => {
                if (circleRenderer == null)
                {
                    circleRenderer           = new MKCircleRenderer(o as MKCircle);
                    circleRenderer.FillColor = UIColor.Purple;
                    circleRenderer.Alpha     = 0.5f;
                }
                return(circleRenderer);
            };

            circleOverlay = MKCircle.Circle(coords, 400);
            mapView.AddOverlay(circleOverlay);

            #region Not related to this sample
            int typesWidth = 260, typesHeight = 30, distanceFromBottom = 60;
            mapTypes = new UISegmentedControl(new CGRect((View.Bounds.Width - typesWidth) / 2, View.Bounds.Height - distanceFromBottom, typesWidth, typesHeight));
            mapTypes.BackgroundColor    = UIColor.White;
            mapTypes.Layer.CornerRadius = 5;
            mapTypes.ClipsToBounds      = true;
            mapTypes.InsertSegment("Road", 0, false);
            mapTypes.InsertSegment("Satellite", 1, false);
            mapTypes.InsertSegment("Hybrid", 2, false);
            mapTypes.SelectedSegment  = 1;            // Road is the default
            mapTypes.AutoresizingMask = UIViewAutoresizing.FlexibleTopMargin;
            mapTypes.ValueChanged    += (s, e) => {
                switch (mapTypes.SelectedSegment)
                {
                case 0:
                    mapView.MapType = MKMapType.Standard;
                    break;

                case 1:
                    mapView.MapType = MKMapType.Satellite;
                    break;

                case 2:
                    mapView.MapType = MKMapType.Hybrid;
                    break;
                }
            };
            View.AddSubview(mapTypes);
            #endregion
        }
コード例 #5
0
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);

            if (e.OldElement != null)
            {
                var nativeMap = Control as MKMapView;
                if (nativeMap != null)
                {
                    nativeMap.RemoveOverlays(nativeMap.Overlays);
                    nativeMap.OverlayRenderer = null;
                    circleRenderer            = null;
                }
            }

            if (e.NewElement != null)
            {
                var formsMap  = (CustomMap2)e.NewElement;
                var nativeMap = Control as MKMapView;
                var circle    = formsMap.Circle;

                nativeMap.OverlayRenderer = GetOverlayRenderer;

                var circleOverlay = MKCircle.Circle(new CoreLocation.CLLocationCoordinate2D(circle.Position.Latitude, circle.Position.Longitude), circle.Radius);
                customPins = formsMap.CustomPins;
                nativeMap.AddOverlay(circleOverlay);
            }
        }
コード例 #6
0
        /*
         * Gets the new overlay renderer for the lines and circles
         */
        public MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlayWrapper)
        {
            var overlay = Runtime.GetNSObject(overlayWrapper.Handle) as IMKOverlay;

            if (overlay.GetType() == typeof(MKPolyline))
            {
                if (polylineRenderer == null && !Equals(overlayWrapper, null))
                {
                    polylineRenderer = new MKPolylineRenderer(overlay as MKPolyline)
                    {
                        StrokeColor = UIColor.Blue,
                        LineWidth   = (System.nfloat) 2.0,
                        Alpha       = 0.4f,
                    };
                }

                return(polylineRenderer);
            }
            else
            {
                if (circleRenderer == null && !Equals(overlayWrapper, null))
                {
                    circleRenderer = new MKCircleRenderer(overlay as MKCircle)
                    {
                        FillColor = UIColor.Black,
                        Alpha     = 0.4f,
                    };
                }
                return(circleRenderer);
            }
        }
コード例 #7
0
        public MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            MKCircleRenderer circleRenderer = new MKCircleRenderer((MKCircle)overlay);

            circleRenderer.FillColor = UIColor.Blue;
            circleRenderer.Alpha     = 0.1f;
            return(circleRenderer);
        }
コード例 #8
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
            RangeMapView.MapType = MapKit.MKMapType.Hybrid;
            //RangeMapView.PitchEnabled = true;

            lm = new CLLocationManager {
                DesiredAccuracy = 500
            };

            if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
            {
                lm.RequestWhenInUseAuthorization();
            }

            lastKnowLocation = lm.Location;

            if (CLLocationManager.LocationServicesEnabled)
            {
                lm.LocationsUpdated += Lm_LocationsUpdated;
                lm.StartUpdatingLocation();
            }

            RangeMapView.OverlayRenderer += (mapView, overlay) =>
            {
                if (overlay is MKCircle)
                {
                    var renderer = new MKCircleRenderer((MKCircle)overlay)
                    {
                        FillColor = UIColor.FromRGBA(0f, .5f, 1f, .3f)
                                    //FillColor = UIColor.Purple
                    };
                    return(renderer);
                }
                return(null);
            };

            var normalRangeRadius = SpecFieldList.FirstOrDefault(row => row.FieldName == "Normal Range");
            var maxRangeRadius    = SpecFieldList.FirstOrDefault(row => row.FieldName == "Max Range");


            normalRangeMeters = 0;
            if (normalRangeRadius != null)
            {
                int normRangeMiles;
                int.TryParse(normalRangeRadius.FieldValue.Split(' ')[0], out normRangeMiles);

                normalRangeMeters = (int)((double)normRangeMiles * 1852d);
            }

            maxRangeMeters = 0;
            if (maxRangeRadius != null)
            {
                int maxRangeMiles;
                int.TryParse(maxRangeRadius.FieldValue.Split(' ')[0], out maxRangeMiles);
                maxRangeMeters = (int)((double)maxRangeMiles * 1852d);;
            }
        }
コード例 #9
0
ファイル: CustomMapRenderer.cs プロジェクト: yofanana/recipes
 MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlay)
 {
     if (circleRenderer == null) {
         circleRenderer = new MKCircleRenderer (overlay as MKCircle);
         circleRenderer.FillColor = UIColor.Red;
         circleRenderer.Alpha = 0.4f;
     }
     return circleRenderer;
 }
コード例 #10
0
        MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            var circleRenderer = new MKCircleRenderer(overlay as MKCircle);

            circleRenderer.FillColor = UIColor.Yellow;
            circleRenderer.Alpha     = 0.2f;

            return(circleRenderer);
        }
コード例 #11
0
        public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            var circleOverlay = overlay as MKCircle;
            var circleView    = new MKCircleRenderer(circleOverlay);

            circleView.FillColor = UIColor.Red;
            circleView.Alpha     = 0.4f;
            return(circleView);
        }
コード例 #12
0
 public void removeOverlays()
 {
     if (nativeMap.Overlays != null && nativeMap.Overlays.Length > 0)
     {
         nativeMap.RemoveOverlay(nativeMap.Overlays[0]);
         this.circleRenderer       = null;
         nativeMap.OverlayRenderer = this.GetOverlayRenderer;
     }
 }
コード例 #13
0
        public MKOverlayRenderer GetRenderer()
        {
            if (_renderer == null)
            {
                _renderer = new MKCircleRenderer(this);
                Update();
            }

            return(_renderer);
        }
コード例 #14
0
        public MKOverlayRenderer GetRenderer()
        {
            if (_renderer == null)
            {
                _renderer = new MKCircleRenderer(this);
                Update();
            }

            return _renderer;
        }
コード例 #15
0
 MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlay)
 {
     if (circleRenderer == null)
     {
         circleRenderer           = new MKCircleRenderer(overlay as MKCircle);
         circleRenderer.FillColor = UIColor.Red;
         circleRenderer.Alpha     = 0.4f;
     }
     return(circleRenderer);
 }
コード例 #16
0
        MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            var o = ObjCRuntime.Runtime.GetNSObject(overlay.Handle) as MKCircle;

            MKCircleRenderer circleRenderer = new MKCircleRenderer(o);

            circleRenderer.FillColor = UIColor.Red;
            circleRenderer.Alpha     = 0.4f;

            return(circleRenderer);
        }
コード例 #17
0
        /// <summary>
        /// Clears the highlighted organ expiry range
        /// </summary>
        private void clearOrganRange()
        {
            if (!(highlightedOrganRange.Item2 == null))
            {
                nativeMap.RemoveOverlay(highlightedOrganRange.Item2);
                this.circleRenderer       = null;
                nativeMap.OverlayRenderer = this.GetOverlayRenderer;
            }

            highlightedOrganRange = new Tuple <CustomPin, MKCircle>(null, null);
        }
コード例 #18
0
ファイル: MapViewController.cs プロジェクト: omxeliw/recipes
        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            Title = "Pyramids of Giza";

            mapView = new MKMapView(View.Bounds);
            mapView.AutoresizingMask = UIViewAutoresizing.FlexibleDimensions;
            View.AddSubview(mapView);

            var coords = new CLLocationCoordinate2D(29.976111, 31.132778); // pyramids of giza, egypt
            var span = new MKCoordinateSpan(MilesToLatitudeDegrees(.75), MilesToLongitudeDegrees(.75, coords.Latitude));
            // set the coords and zoom on the map
            mapView.MapType = MKMapType.Satellite;
            mapView.Region = new MKCoordinateRegion(coords, span);

            mapView.OverlayRenderer = (m, o) => {
                if(circleRenderer == null)
                {
                    circleRenderer = new MKCircleRenderer(o as MKCircle);
                    circleRenderer.FillColor = UIColor.Purple;
                    circleRenderer.Alpha = 0.5f;
                }
                return circleRenderer;
            };

            circleOverlay = MKCircle.Circle (coords, 200);
            mapView.AddOverlay (circleOverlay);

            #region Not related to this sample
            int typesWidth=260, typesHeight=30, distanceFromBottom=60;
            mapTypes = new UISegmentedControl(new CGRect((View.Bounds.Width-typesWidth)/2, View.Bounds.Height-distanceFromBottom, typesWidth, typesHeight));
            mapTypes.InsertSegment("Road", 0, false);
            mapTypes.InsertSegment("Satellite", 1, false);
            mapTypes.InsertSegment("Hybrid", 2, false);
            mapTypes.SelectedSegment = 1; // Road is the default
            mapTypes.AutoresizingMask = UIViewAutoresizing.FlexibleTopMargin;
            mapTypes.ValueChanged += (s, e) => {
                switch(mapTypes.SelectedSegment) {
                case 0:
                    mapView.MapType = MKMapType.Standard;
                    break;
                case 1:
                    mapView.MapType = MKMapType.Satellite;
                    break;
                case 2:
                    mapView.MapType = MKMapType.Hybrid;
                    break;
                }
            };
            View.AddSubview(mapTypes);
            #endregion
        }
コード例 #19
0
 MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlayWrapper)
 {
     if (circleRenderer == null && !Equals(overlayWrapper, null))
     {
         var overlay = Runtime.GetNSObject(overlayWrapper.Handle) as IMKOverlay;
         circleRenderer = new MKCircleRenderer(overlay as MKCircle)
         {
             FillColor = UIColor.Red,
             Alpha     = 0.4f
         };
     }
     return(circleRenderer);
 }
コード例 #20
0
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);

            if (e.OldElement != null)
            {
                var nativeMap = Control as MKMapView;
                if (nativeMap != null)
                {
                    nativeMap.RemoveOverlays(nativeMap.Overlays);
                    nativeMap.OverlayRenderer = null;
                    circleRenderer            = null;
                }
            }
        }
コード例 #21
0
        MKOverlayRenderer GetOverlayRendererCircle(MKMapView mapView, IMKOverlay overlayWrapper)
        {//MOYENNE
            //if (polylineRenderer == null && !Equals(overlayWrapper, null))
            //{
            var overlay = Runtime.GetNSObject(overlayWrapper.Handle) as IMKOverlay;

            circleRenderer = new MKCircleRenderer(overlay as MKCircle)
            {
                FillColor   = UIColor.FromRGBA(0, 0, 0, 0),
                StrokeColor = UIColor.FromRGBA(250, 250, 250, 250),
                LineWidth   = 5f
            };
            //}

            return(circleRenderer);
        }
コード例 #22
0
        MKOverlayRenderer GetOverlayRendererCircleMax(MKMapView mapView, IMKOverlay overlayWrapper)
        {
            //if (polylineRenderer == null && !Equals(overlayWrapper, null))
            //{
            var overlay = Runtime.GetNSObject(overlayWrapper.Handle) as IMKOverlay;

            circleRenderer = new MKCircleRenderer(overlay as MKCircle)
            {
                FillColor   = UIColor.Green,
                StrokeColor = UIColor.FromRGBA(230, 20, 170, 20),
                Alpha       = 0.5f
            };
            //}

            return(circleRenderer);
        }
コード例 #23
0
 public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
 {
     if (overlay is MKPolygon)
     {
         var polygon     = overlay as MKPolygon;
         var polygonView = new MKPolygonRenderer(polygon);
         if (MapControlManager.IsOutOf && !ModeZoneFirstView.IsOnModeZone)
         {
             polygonView.FillColor   = UIColor.FromRGB(255, 76, 57).ColorWithAlpha((nfloat)0.4);
             polygonView.StrokeColor = UIColor.FromRGB(255, 76, 57).ColorWithAlpha((nfloat)0.2);
         }
         else
         {
             polygonView.FillColor   = UIColor.FromRGB(98, 218, 115).ColorWithAlpha((nfloat)0.4);
             polygonView.StrokeColor = UIColor.FromRGB(98, 218, 115).ColorWithAlpha((nfloat)0.2);
         }
         polygonView.LineWidth = 1;
         return(polygonView);
     }
     else if (overlay is MKCircle)
     {
         var circle     = overlay as MKCircle;
         var circleView = new MKCircleRenderer(circle);
         circleView.FillColor = UIColor.Blue;
         circleView.Alpha     = 0.2f;
         return(circleView);
     }
     else if (overlay is MKPolyline)
     {
         MKPolylineRenderer polylineRenderer = new MKPolylineRenderer(overlay as MKPolyline);
         if (MapControlManager.IsOutOf && !ModeZoneFirstView.IsOnModeZone)
         {
             polylineRenderer.FillColor   = UIColor.FromRGB(255, 76, 57);
             polylineRenderer.StrokeColor = UIColor.FromRGB(255, 76, 57);
         }
         else
         {
             polylineRenderer.FillColor   = UIColor.FromRGB(98, 218, 115);
             polylineRenderer.StrokeColor = UIColor.FromRGB(98, 218, 115);
         }
         polylineRenderer.LineWidth = 2;
         polylineRenderer.Alpha     = 0.8f;
         return(polylineRenderer);
     }
     return(null);
 }
コード例 #24
0
        protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            base.OnElementPropertyChanged(sender, e);

            var formsMap = Element as CustomMap;
            var centre   = formsMap.MapPosition;
            var radius   = formsMap.CircleRadius;

            var nativeMap = Control as MKMapView;

            if (e.PropertyName == "CircleRadius" || e.PropertyName == "MapPosition")
            {
                nativeMap.RemoveOverlay(_circleOverlay);
                nativeMap.OverlayRenderer = null;
                _circleRenderer           = null;

                nativeMap.OverlayRenderer = GetOverlayRenderer;
                _circleOverlay            = MKCircle.Circle(new CoreLocation.CLLocationCoordinate2D(centre.Latitude, centre.Longitude), radius);
                nativeMap.AddOverlay(_circleOverlay);
            }
        }
コード例 #25
0
        void FindZombieInfestedZones()
        {
            var circleOverlay = MKCircle.Circle(CDC.Coordinates, radius);

            map.AddOverlay(circleOverlay);

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle)
                {
                    circleRenderer = new MKCircleRenderer(overlay as MKCircle)
                    {
                        FillColor = UIColor.Red,
                        Alpha     = 0.5f
                    };
                    return(circleRenderer);
                }
                return(null);
            };

            Helpers.CenterOnAtlanta(map);
        }
コード例 #26
0
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);

            if (e.OldElement != null)
            {
                var nativeMap = Control as MKMapView;
                if (nativeMap != null && nativeMap.Overlays != null)
                {
                    nativeMap.RemoveOverlays(nativeMap.Overlays);
                    nativeMap.OverlayRenderer = null;
                    circleRenderer            = null;
                    polylineRenderer          = null;
                }
                nativeMap.GetViewForAnnotation           = null;
                nativeMap.CalloutAccessoryControlTapped -= OnCalloutAccessoryControlTapped;
                nativeMap.DidSelectAnnotationView       -= OnDidSelectAnnotationView;
                nativeMap.DidDeselectAnnotationView     -= OnDidDeselectAnnotationView;
            }

            if (e.NewElement != null)
            {
                formsMap  = (CustomMap)e.NewElement;
                nativeMap = Control as MKMapView;
                nativeMap.OverlayRenderer = GetOverlayRenderer;

                customPins     = formsMap.CustomPins;
                helicopterPins = formsMap.HelicopterPins;

                intialiseHelicopterIcons();

                highlightedFlightPath = new Tuple <CustomPin, MKPolyline>(null, null);
                highlightedOrganRange = new Tuple <CustomPin, MKCircle>(null, null);

                nativeMap.GetViewForAnnotation           = GetViewForAnnotation;
                nativeMap.CalloutAccessoryControlTapped += OnCalloutAccessoryControlTapped;
                nativeMap.DidSelectAnnotationView       += OnDidSelectAnnotationView;
                nativeMap.DidDeselectAnnotationView     += OnDidDeselectAnnotationView;
            }
        }
コード例 #27
0
        void FindSafeZones()
        {
            var polygonOverlay = MKPolygon.FromCoordinates(new CLLocationCoordinate2D[] {
                new CLLocationCoordinate2D(45.00, -111.00),
                new CLLocationCoordinate2D(45, -104),
                new CLLocationCoordinate2D(41, -104),
                new CLLocationCoordinate2D(41, -111)
            });

            map.AddOverlay(polygonOverlay);

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle)
                {
                    if (circleRenderer == null)
                    {
                        circleRenderer = new MKCircleRenderer(overlay as MKCircle)
                        {
                            FillColor = UIColor.Red,
                            Alpha     = 0.5f
                        };
                    }
                    return(circleRenderer);
                }
                else if (overlay is MKPolygon)
                {
                    if (polyRenderer == null)
                    {
                        polyRenderer           = new MKPolygonRenderer(overlay as MKPolygon);
                        polyRenderer.FillColor = UIColor.Green;
                        polyRenderer.Alpha     = 0.5f;
                    }
                    return(polyRenderer);
                }
                return(null);
            };

            Helpers.CenterOnCheyenne(map);
        }
コード例 #28
0
        public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            if (overlay is MKCircle)
            {
                var renderer = new MKCircleRenderer((MKCircle)overlay)
                {
                    FillColor = UIColor.FromRGBA(0.0f, 0.5f, 1.0f, 0.5f)
                };
                return(renderer);
            }

            if (overlay is MKPolyline)
            {
                var route    = (MKPolyline)overlay;
                var renderer = new MKPolylineRenderer(route)
                {
                    StrokeColor = UIColor.Red, LineWidth = 3.0f
                };
                return(renderer);
            }
            return(null);
        }
コード例 #29
0
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);

            if (e.OldElement != null)
            {
                var nativeMap = Control as MKMapView;
                nativeMap.OverlayRenderer = null;
            }

            if (e.NewElement != null)
            {
                var formsMap = (MapWithRoute)e.NewElement;
                nativeMap    = Control as MKMapView;
                mapWithRoute = formsMap;

                nativeMap.OverlayRenderer = GetOverlayRenderer;
                nativeMap.OverlayRenderer = (m, o) => {
                    if (circleRenderer == null)
                    {
                        var circle = o as MKCircle;
                        if (circle != null)
                        {
                            circleRenderer           = new MKCircleRenderer(circle);
                            circleRenderer.FillColor = UIColor.Blue;
                            circleRenderer.Alpha     = 0.5f;
                        }
                    }
                    return(circleRenderer);
                };

                formsMap.PropertyChanged += OnChange;

                addOverLayForCalulatedRoute(formsMap, nativeMap);
                addOverLayForFlownRoute(formsMap, nativeMap);
            }
        }
コード例 #30
0
        protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            base.OnElementPropertyChanged(sender, e);

            if (e.PropertyName == CustomMap.PointsProperty.PropertyName)
            {
                var mapView   = (MKMapView)Control;
                var customMap = (CustomMap)Element;

                mapView.OverlayRenderer = (map, overlay) =>
                {
                    var circle = overlay as MKCircle;

                    if (circle != null)
                    {
                        var point = customMap.Points.Single(x => x.Location.Latitude == circle.Coordinate.Latitude && x.Location.Longitude == circle.Coordinate.Longitude);

                        var circleRenderer = new MKCircleRenderer(circle)
                        {
                            FillColor = point.Heat.ToUIColor(),
                            Alpha     = 1.0f
                        };

                        return(circleRenderer);
                    }

                    return(null);
                };

                foreach (var point in customMap.Points)
                {
                    var overlay = MKCircle.Circle(new CoreLocation.CLLocationCoordinate2D(point.Location.Latitude, point.Location.Longitude), 100);

                    mapView.AddOverlay(overlay);
                }
            }
        }
コード例 #31
0
ファイル: RouteMapRenderer.cs プロジェクト: vplme/tabi-app
        MKOverlayRenderer GetOverlayRenderer(MKMapView mapView, IMKOverlay overlayWrapper)
        {
            MKOverlayRenderer renderer = null;

            var overlay = Runtime.GetNSObject(overlayWrapper.Handle) as IMKOverlay;

            Type overlayType = overlayWrapper.GetType();

            if (overlayType == typeof(MKCircle))
            {
                MKCircleRenderer circleRenderer = new MKCircleRenderer(overlay as MKCircle)
                {
                    FillColor = currentFillColor.ColorWithAlpha(0.1f),
                };

                if (currentLineWidth != 0)
                {
                    circleRenderer.StrokeColor = currentStrokeColor;
                    circleRenderer.LineWidth   = currentLineWidth;
                }

                renderer = circleRenderer;
            }

            else if (overlayType == typeof(MKPolyline))
            {
                renderer = new MKPolylineRenderer(overlay as MKPolyline)
                {
                    FillColor   = currentFillColor,
                    StrokeColor = currentStrokeColor,
                    LineWidth   = 3,
                    Alpha       = 0.4f
                };
            }
            return(renderer);
        }
コード例 #32
0
        public override MKOverlayRenderer OverlayRenderer(MKMapView mapView, IMKOverlay overlay)
        {
            if (overlay is MKCircle)
            {
                if (circleRenderer == null)
                {
                    circleRenderer = new MKCircleRenderer(overlay as MKCircle);
                    circleRenderer.FillColor = UIColor.Purple;
                    circleRenderer.Alpha = 0.5f;
                }
                return circleRenderer;

            } else if (overlay is MKPolygon)
            {
                if (polyRenderer == null)
                {
                    polyRenderer = new MKPolygonRenderer(overlay as MKPolygon);
                    polyRenderer.FillColor = UIColor.Green;
                    polyRenderer.Alpha = 0.5f;
                }
                return polyRenderer;
            } else
            {
                Debug.WriteLine("OverlayRenderer() - Unknown overlay type!");
                return null;
            }

        }            
コード例 #33
0
        void FindZombieInfestedZones()
        {
            var circleOverlay = MKCircle.Circle (CDC.Coordinates, radius);
            map.AddOverlay (circleOverlay);

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle) {
                    circleRenderer = new MKCircleRenderer (overlay as MKCircle) {
                        FillColor = UIColor.Red,
                        Alpha = 0.5f
                    };
                    return circleRenderer;
                }
                return null;
            };

            Helpers.CenterOnAtlanta (map);
        }
コード例 #34
0
        void FindRouteToSafeZone()
        {
            MKPlacemarkAddress address = null;

            //Start at our current location
            var fromLocation = new MKPlacemark (CDC.Coordinates, address);

            //Go to the safe zone
            var destinationLocation = new MKPlacemark (new CLLocationCoordinate2D (Cheyenne.Latitude, Cheyenne.Longitude), address);

            var request = new MKDirectionsRequest {
                Source = new MKMapItem (fromLocation),
                Destination = new MKMapItem (destinationLocation),
                RequestsAlternateRoutes = false
            };

            var directions = new MKDirections (request);

            //Async network call to Apple's servers
            directions.CalculateDirections ((response, error) => {
                if (error != null) {
                    Console.WriteLine (error.LocalizedDescription);
                } else {

                    foreach (var route in response.Routes) {
                        map.AddOverlay (route.Polyline);
                    }
                }
            });

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle) {
                    if (circleRenderer == null) {
                        circleRenderer = new MKCircleRenderer (overlay as MKCircle) {
                            FillColor = UIColor.Red,
                            Alpha = 0.5f
                        };
                    }
                    return circleRenderer;
                } else if (overlay is MKPolygon) {
                    if (polyRenderer == null) {
                        polyRenderer = new MKPolygonRenderer (overlay as MKPolygon);
                        polyRenderer.FillColor = UIColor.Green;
                        polyRenderer.Alpha = 0.5f;
                    }
                    return polyRenderer;
                } else if (overlay is MKPolyline) {
                    var route = (MKPolyline)overlay;
                    var renderer = new MKPolylineRenderer (route) {
                        StrokeColor = UIColor.Blue
                    };
                    return renderer;
                }
                return null;
            };

            Helpers.CenterOnUnitedStates (map);
        }
コード例 #35
0
        void FindRouteToSafeZone()
        {
            MKPlacemarkAddress address = null;

            //Start at our current location
            var fromLocation = new MKPlacemark(CDC.Coordinates, address);

            //Go to the safe zone
            var destinationLocation = new MKPlacemark(new CLLocationCoordinate2D(Cheyenne.Latitude, Cheyenne.Longitude), address);

            var request = new MKDirectionsRequest {
                Source                  = new MKMapItem(fromLocation),
                Destination             = new MKMapItem(destinationLocation),
                RequestsAlternateRoutes = false
            };

            var directions = new MKDirections(request);

            //Async network call to Apple's servers
            directions.CalculateDirections((response, error) => {
                if (error != null)
                {
                    Console.WriteLine(error.LocalizedDescription);
                }
                else
                {
                    foreach (var route in response.Routes)
                    {
                        map.AddOverlay(route.Polyline);
                    }
                }
            });

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle)
                {
                    if (circleRenderer == null)
                    {
                        circleRenderer = new MKCircleRenderer(overlay as MKCircle)
                        {
                            FillColor = UIColor.Red,
                            Alpha     = 0.5f
                        };
                    }
                    return(circleRenderer);
                }
                else if (overlay is MKPolygon)
                {
                    if (polyRenderer == null)
                    {
                        polyRenderer           = new MKPolygonRenderer(overlay as MKPolygon);
                        polyRenderer.FillColor = UIColor.Green;
                        polyRenderer.Alpha     = 0.5f;
                    }
                    return(polyRenderer);
                }
                else if (overlay is MKPolyline)
                {
                    var route    = (MKPolyline)overlay;
                    var renderer = new MKPolylineRenderer(route)
                    {
                        StrokeColor = UIColor.Blue
                    };
                    return(renderer);
                }
                return(null);
            };

            Helpers.CenterOnUnitedStates(map);
        }
コード例 #36
0
        void FindSafeZones()
        {
            var polygonOverlay = MKPolygon.FromCoordinates (new CLLocationCoordinate2D[] {
                new CLLocationCoordinate2D (45.00, -111.00),
                new CLLocationCoordinate2D (45, -104),
                new CLLocationCoordinate2D (41, -104),
                new CLLocationCoordinate2D (41, -111)
            });

            map.AddOverlay (polygonOverlay);

            map.OverlayRenderer = (mapView, overlay) => {
                if (overlay is MKCircle) {
                    if (circleRenderer == null) {
                        circleRenderer = new MKCircleRenderer (overlay as MKCircle) {
                            FillColor = UIColor.Red,
                            Alpha = 0.5f
                        };
                    }
                    return circleRenderer;
                } else if (overlay is MKPolygon) {
                    if (polyRenderer == null) {
                        polyRenderer = new MKPolygonRenderer (overlay as MKPolygon);
                        polyRenderer.FillColor = UIColor.Green;
                        polyRenderer.Alpha = 0.5f;
                    }
                    return polyRenderer;
                }
                return null;
            };

            Helpers.CenterOnCheyenne (map);
        }