====== Source Code iOSEditionSample GettingStarted.zip ======

====AppDelegate.cs====

<code csharp>   
 using Foundation;  
 using UIKit;  
 using System;  
  
 namespace GettingStartedSample  
 {  
     // The UIApplicationDelegate for the application. This class is responsible for launching the  
     // User Interface of the application, as well as listening (and optionally responding) to  
     // application events from iOS.  
     [Register("AppDelegate")]  
     public partial class AppDelegate : UIApplicationDelegate  
     {  
         // class-level declarations  
         public override UIWindow Window  
         {  
             get;  
             set;  
         }  
         // This method is invoked when the application is about to move from active to inactive state.  
         // OpenGL applications should use this method to pause.  
         public override void OnResignActivation(UIApplication application)  
         {  
         }  
         // This method should be used to release shared resources and it should store the application state.  
         // If your application supports background exection this method is called instead of WillTerminate  
         // when the user quits.  
         public override void DidEnterBackground(UIApplication application)  
         {  
         }  
         // This method is called as part of the transiton from background to active state.  
         public override void WillEnterForeground(UIApplication application)  
         {  
             AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;  
         }  
  
         void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)  
         {  
             Console.WriteLine();  
         }  
         // This method is called when the application is about to terminate. Save data, if needed.  
         public override void WillTerminate(UIApplication application)  
         {  
         }  
     }  
 }  
  
 </code>

====Main.cs====

<code csharp>   
  
 using UIKit;  
  
 namespace GettingStartedSample  
 {  
     public class Application  
     {  
         // This is the main entry point of the application.  
         static void Main(string[] args)  
         {  
             // if you want to use a different Application Delegate class from "AppDelegate"  
             // you can specify it here.  
             UIApplication.Main(args, null, "AppDelegate");  
         }  
     }  
 }  
 </code>

====MainViewController.cs====

<code csharp>   
 using CoreAnimation;  
 using CoreGraphics;  
 using CoreLocation;  
 using Foundation;  
 using UIKit;  
 using System;  
 using System.Collections.Generic;  
 using System.Drawing;  
 using System.Globalization;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.iOSEdition;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the main window  
     /// </summary>  
     public partial class MainViewController : UIViewController  
     {  
         private static readonly Dictionary<string, double> zoomLevelOptions;  
  
         private MapView mapView;  
         private InstructionView instructionView;  
         private CLLocationManager locationManager;  
         private Proj4Projection bingToWgs84Projection;  
         private long previousLocationUpdatedTicks;  
  
         static MainViewController()  
         {  
             zoomLevelOptions = new Dictionary<string, double>();  
             zoomLevelOptions["Zoom|to zoomlevel 2"] = 295295895;  
             zoomLevelOptions["Zoom|to zoomlevel 5"] = 36911986;  
             zoomLevelOptions["Zoom|to zoomlevel 10"] = 1153499;  
             zoomLevelOptions["Zoom|to zoomlevel 16"] = 18023;  
             zoomLevelOptions["Zoom|to zoomlevel 18"] = 4505;  
         }  
  
         public MainViewController(IntPtr handle)  
             : base(handle)  
         { }  
  
         public override void ViewDidLoad()  
         {  
             base.ViewDidLoad();  
  
             iOSCapabilityHelper.SetViewLayout(View);  
             InitializeMap();  
             InitializeTools();  
             InitializeZoomToScaleDialog();  
             InitializeGpsLocationManager();  
         }  
  
         public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation)  
         {  
             base.DidRotate(fromInterfaceOrientation);  
  
             instructionView.DidRotate();  
             instructionView.Hidden = false;  
             mapView.MapTools["ScaleTool"].IsEnabled = true;  
             mapView.MapTools.CenterCoordinate.IsEnabled = true;  
         }  
  
         public override void WillAnimateRotation(UIInterfaceOrientation toInterfaceOrientation, double duration)  
         {  
             base.WillAnimateRotation(toInterfaceOrientation, duration);  
  
             double resolution = Math.Max(mapView.CurrentExtent.Width / mapView.Frame.Width, mapView.CurrentExtent.Height / mapView.Frame.Height);  
             mapView.Frame = View.Bounds;  
             mapView.CurrentExtent = GetExtentRetainScale(mapView.CurrentExtent.GetCenterPoint(), mapView.Frame, resolution);  
             mapView.Refresh();  
         }  
  
         public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration)  
         {  
             base.WillRotate(toInterfaceOrientation, duration);  
             instructionView.Hidden = true;  
             mapView.MapTools["ScaleTool"].IsEnabled = false;  
             mapView.MapTools.CenterCoordinate.IsEnabled = false;  
         }  
  
         private void InitializeMap()  
         {  
             bingToWgs84Projection = new Proj4Projection();  
             bingToWgs84Projection.InternalProjectionParametersString = ManagedProj4Projection.GetBingMapParametersString();  
             bingToWgs84Projection.ExternalProjectionParametersString = ManagedProj4Projection.GetWgs84ParametersString();  
             bingToWgs84Projection.Open();  
  
             mapView = new MapView(View.Frame);  
             mapView.MapUnit = GeographyUnit.Meter;  
             mapView.BackgroundColor = UIColor.FromRGB(244, 242, 238);  
             mapView.CurrentExtent = new RectangleShape(-13939426.6371, 6701997.4056, -7812401.86, 2626987.386962);  
             View.AddSubview(mapView);  
  
             // Touch events  
             mapView.MapSingleTap += MapView_MapSingleTap;  
             mapView.MapLongPress += MapView_MapLongPress;  
  
             // Base overlay.  
             WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();  
             worldOverlay.TileType = TileType.MultiTile;  
             worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             mapView.Overlays.Add("WMK", worldOverlay);  
  
             // Location marker layer.  
             MarkerOverlay locationOverlay = new MarkerOverlay();  
             mapView.Overlays.Add("LocationOverlay", locationOverlay);  
  
             // Single tap popup overlay.  
             PopupOverlay popupOverlay = new PopupOverlay();  
             popupOverlay.OverlayView.UserInteractionEnabled = true;  
             mapView.Overlays.Add("PopupOverlay", popupOverlay);  
  
             mapView.MapTools.CenterCoordinate.IsEnabled = true;  
             mapView.MapTools.CenterCoordinate.DisplayProjection = bingToWgs84Projection;  
             mapView.MapTools.CenterCoordinate.DisplayTextFormat = "Longitude:{0:N4}, Latitude:{1:N4}";  
  
             ScaleZoomLevelMapTool scaleTool = new ScaleZoomLevelMapTool();  
             scaleTool.IsEnabled = true;  
             mapView.MapTools.Add("ScaleTool", scaleTool);  
             mapView.Refresh();  
         }  
  
         private void InitializeTools()  
         {  
             instructionView = new InstructionView(View, RefreshInstructionView, Instruction_ExpandStateChanged);  
             Add(instructionView);  
         }  
  
         private void InitializeZoomToScaleDialog()  
         {  
             longPressDailog.Layer.BorderColor = UIColor.Gray.CGColor;  
             longPressDailog.Layer.BorderWidth = 3;  
             longPressDailog.Layer.ShadowColor = UIColor.Gray.CGColor;  
             longPressDailog.Layer.ShadowRadius = 2;  
             longPressDailog.Layer.ShadowOpacity = .6f;  
             longPressDailog.Layer.ShadowOffset = new SizeF(1, 1);  
  
             TableViewSource longPressOptions_Source = new TableViewSource();  
             SectionModel section = new SectionModel();  
             foreach (var zoomLevelOption in zoomLevelOptions)  
             {  
                 section.Rows.Add(new CellModel(zoomLevelOption.Key));  
             }  
  
             longPressOptions_Source.Sections.Add(section);  
             longPressOptions_Source.RowClick += LongPressOptionsSource_RowClick;  
             tbvLongPressOptions.Source = longPressOptions_Source;  
  
             View.BringSubviewToFront(dailogBackground);  
             View.BringSubviewToFront(longPressDailog);  
             dailogBackground.Hidden = true;  
             longPressDailog.Hidden = true;  
         }  
  
         private void InitializeGpsLocationManager()  
         {  
             locationManager = new CLLocationManager();  
             iOSCapabilityHelper.SetGpsLocationManagerCapability(locationManager);  
             locationManager.DesiredAccuracy = 1;  
             locationManager.LocationsUpdated += LocationManager_LocationsUpdated;  
             locationManager.StartUpdatingLocation();  
         }  
  
         /// <summary>  
         /// Handles the LocationsUpdated event of the LocationManager control.  
         /// </summary>  
         /// <param name="sender">The source of the event.</param>  
         /// <param name="e">The <see cref="CLLocationsUpdatedEventArgs"/> instance containing the event data.</param>  
         private void LocationManager_LocationsUpdated(object sender, CLLocationsUpdatedEventArgs e)  
         {  
             long currentTicks = DateTime.Now.Ticks;  
             // Check the location update time, if is less that 5 seconds, don't need update the GPS marker.  
             if (TimeSpan.FromTicks(currentTicks - previousLocationUpdatedTicks).TotalSeconds > 5 && !mapView.ExtentOverlay.IsBusy)  
             {  
                 previousLocationUpdatedTicks = currentTicks;  
             }  
             else  
             {  
                 return;  
             }  
  
             CLLocation gpsLocation = e.Locations.FirstOrDefault();  
             if (gpsLocation == null) return;  
  
             PointShape currentLocationInWgs84 = new PointShape(gpsLocation.Coordinate.Longitude, gpsLocation.Coordinate.Latitude);  
             PointShape currentLocationInMercator = (PointShape)bingToWgs84Projection.ConvertToInternalProjection(currentLocationInWgs84);  
  
             MarkerOverlay locationOverlay = (MarkerOverlay)mapView.Overlays["LocationOverlay"];  
             GpsMarker locationMarker = locationOverlay.Markers.OfType<GpsMarker>().FirstOrDefault();  
  
             // Create a location marker if not exists.  
             if (locationMarker == null)  
             {  
                 locationMarker = new GpsMarker();  
                 locationOverlay.Markers.Add(locationMarker);  
             }  
  
             // Update the GPS marker position.  
             locationMarker.HaloRadiusInMeter = (float)gpsLocation.HorizontalAccuracy;  
             locationMarker.Position = currentLocationInMercator;  
             locationOverlay.Refresh();  
         }  
  
         private void LongPressOptionsSource_RowClick(object sender, TableViewRowClickEventArgs e)  
         {  
             CellModel row = ((TableViewSource)e.TableView.Source).Sections[e.IndexPath.Section].Rows[e.IndexPath.Row];  
             double scale = double.Parse(zoomLevelOptions[row.Name].ToString(CultureInfo.InvariantCulture));  
             mapView.ZoomToScale(scale);  
  
             SetZoomToScaleDialogIsHidden(true);  
         }  
  
         private void Instruction_ExpandStateChanged(CGRect instructionFrame, bool animate)  
         {  
             if (animate)  
             {  
                 UIView.BeginAnimations("MapToolsPositionChanged");  
                 UIView.SetAnimationDuration(0.2);  
             }  
             MapTool scaleTool = mapView.MapTools["ScaleTool"];  
             MapTool coordinateTool = mapView.MapTools.CenterCoordinate;  
  
             coordinateTool.Center = new CGPoint(View.Frame.Width - scaleTool.Frame.Width / 2 - 5, instructionFrame.Top - 25);  
             scaleTool.Center = new CGPoint(View.Frame.Width - coordinateTool.Frame.Width / 2 - 5, instructionFrame.Top - 40);  
  
             CALayer attributionLayer = mapView.EventView.Layer.Sublayers.FirstOrDefault(l => l.Name.Equals("AttributionLayer"));  
             attributionLayer.Frame = new CGRect(0, -instructionFrame.Height, attributionLayer.Frame.Width, attributionLayer.Frame.Height);  
  
             if (animate) UIView.CommitAnimations();  
         }  
  
         partial void dialogBackground_TouchUpInside(UIButton sender)  
         {  
             SetZoomToScaleDialogIsHidden(true);  
         }  
  
         partial void btnClose_TouchUpInside(UIButton sender)  
         {  
             SetZoomToScaleDialogIsHidden(true);  
         }  
  
         private void MapView_MapSingleTap(object sender, UIGestureRecognizer e)  
         {  
             PointF location = (PointF)e.LocationInView(mapView);  
             PointShape worldPoint = ExtentHelper.ToWorldCoordinate(mapView.CurrentExtent, location.X, location.Y, (float)mapView.Frame.Width, (float)mapView.Frame.Height);  
  
             PointShape wgs84Point = (PointShape)bingToWgs84Projection.ConvertToExternalProjection(worldPoint);  
             string displayText = string.Format("Longitude : {0:N4}\r\nLatitude : {1:N4}", wgs84Point.X, wgs84Point.Y);  
             PopupOverlay popupOverlay = (PopupOverlay)mapView.Overlays["PopupOverlay"];  
             CurrentLocationPopup popup = (CurrentLocationPopup)popupOverlay.Popups.FirstOrDefault() ??  
                 new CurrentLocationPopup(worldPoint, displayText);  
  
             popup.Position = worldPoint;  
             popup.Hidden = false;  
             popup.Content = displayText;  
             popup.UserInteractionEnabled = true;  
  
             popupOverlay.Popups.Clear();  
             popupOverlay.Popups.Add(popup);  
             popupOverlay.Refresh();  
         }  
  
         private void MapView_MapLongPress(object sender, UIGestureRecognizer e)  
         {  
             SetZoomToScaleDialogIsHidden(false);  
         }  
  
         private void LocateButton_TouchUpInside(object sender, EventArgs e)  
         {  
             MarkerOverlay locaterOverlay = (MarkerOverlay)mapView.Overlays["LocationOverlay"];  
             Marker locateMarker = locaterOverlay.Markers.FirstOrDefault();  
             if (locateMarker != null)  
             {  
                 mapView.ZoomTo(locateMarker.Position, 18023);  
             }  
         }  
  
         private void FullExtentButton_TouchUpInside(object sender, EventArgs e)  
         {  
             Overlay worldOverlay = mapView.Overlays["WMK"];  
             mapView.CurrentExtent = worldOverlay.GetBoundingBox();  
             mapView.Refresh();  
         }  
  
         private void PreviousExtentButton_TouchUpInside(object sender, EventArgs e)  
         {  
             mapView.ZoomToPreviousExtent();  
         }  
  
         private void NextExtentButton_TouchUpInside(object sender, EventArgs e)  
         {  
             mapView.ZoomToNextExtent();  
         }  
  
         private void InformationButton_TouchUpInside(object sender, EventArgs e)  
         {  
             UIApplication.SharedApplication.OpenUrl(new NSUrl("http://thinkgeo.com/map-suite-developer-gis/ios-edition/"));  
         }  
  
         private void RefreshInstructionView(UIView contentView)  
         {  
             UIButton locateButton;  
             UIButton fullExtentButton;  
             UIButton previousExtentButton;  
             UIButton nextExtentButton;  
             UIButton informationButton;  
  
             UIInterfaceOrientation orientation = UIApplication.SharedApplication.StatusBarOrientation;  
             // Check the device orientation, refresh the controls layout for instruction view.  
             if (orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight)  
             {  
                 locateButton = InitializeButton(contentView.Bounds.Width - 195, "location40X40", LocateButton_TouchUpInside);  
                 fullExtentButton = InitializeButton(contentView.Bounds.Width - 155, "fullext40X40", FullExtentButton_TouchUpInside);  
                 previousExtentButton = InitializeButton(contentView.Bounds.Width - 115, "Preext40X40", PreviousExtentButton_TouchUpInside);  
                 nextExtentButton = InitializeButton(contentView.Bounds.Width - 75, "Nxtext40X40", NextExtentButton_TouchUpInside);  
                 informationButton = InitializeButton(contentView.Bounds.Width - 35, "info40X40", InformationButton_TouchUpInside);  
             }  
             else  
             {  
                 locateButton = InitializeButton(0, "location40X40", LocateButton_TouchUpInside);  
                 fullExtentButton = InitializeButton(40, "fullext40X40", FullExtentButton_TouchUpInside);  
                 previousExtentButton = InitializeButton(80, "Preext40X40", PreviousExtentButton_TouchUpInside);  
                 nextExtentButton = InitializeButton(120, "Nxtext40X40", NextExtentButton_TouchUpInside);  
                 informationButton = InitializeButton(contentView.Bounds.Width - 35, "info40X40", InformationButton_TouchUpInside);  
             }  
  
             contentView.AddSubview(locateButton);  
             contentView.AddSubview(fullExtentButton);  
             contentView.AddSubview(previousExtentButton);  
             contentView.AddSubview(nextExtentButton);  
             contentView.AddSubview(informationButton);  
         }  
  
         private void SetZoomToScaleDialogIsHidden(bool hidden)  
         {  
             UIView.Animate(0.2, () =>  
             {  
                 dailogBackground.Hidden = hidden;  
                 longPressDailog.Hidden = hidden;  
             });  
         }  
  
         /// <summary>  
         /// Gets the current extend for MapView by frame and GPS location.  
         /// </summary>  
         /// <param name="currentLocationInMercator">The current location in mercator.</param>  
         /// <param name="frame">The frame.</param>  
         /// <param name="resolution">The resolution.</param>  
         private static RectangleShape GetExtentRetainScale(PointShape currentLocationInMercator, CGRect frame, double resolution)  
         {  
             double left = currentLocationInMercator.X - resolution * frame.Width * .5;  
             double right = currentLocationInMercator.X + resolution * frame.Width * .5;  
             double top = currentLocationInMercator.Y + resolution * frame.Height * .5;  
             double bottom = currentLocationInMercator.Y - resolution * frame.Height * .5;  
             return new RectangleShape(left, top, right, bottom);  
         }  
  
         private static UIButton InitializeButton(nfloat x, string imageName, EventHandler touchEventHandler)  
         {  
             UIButton button = UIButton.FromType(UIButtonType.RoundedRect);  
             button.Frame = new CGRect(x, 0, 35, 35);  
             button.TintColor = UIColor.White;  
             button.SetImage(UIImage.FromBundle(imageName), UIControlState.Normal);  
             button.TouchUpInside += touchEventHandler;  
             return button;  
         }  
     }  
 }  
 </code>

====MainViewController.designer.cs====

<code csharp>   
 // WARNING  
 //  
 // This file has been generated automatically by Xamarin Studio from the outlets and  
 // actions declared in your storyboard file.  
 // Manual changes to this file will not be maintained.  
 //  
 using System;  
 using Foundation;  
 using UIKit;  
 using System.CodeDom.Compiler;  
  
 namespace GettingStartedSample  
 {  
 	[Register|("MainViewController")]  
 	partial class MainViewController  
 	{  
 		[Outlet]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		UIButton btnClose { get; set; }  
  
 		[Outlet]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		UIButton dailogBackground { get; set; }  
  
 		[Outlet]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		UIView longPressDailog { get; set; }  
  
 		[Outlet]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		UITableView tbvLongPressOptions { get; set; }  
  
 		[Action|("btnClose_TouchUpInside:")]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		partial void btnClose_TouchUpInside (UIButton sender);  
  
 		[Action|("dailogBackground_TouchUpInside:")]  
 		[GeneratedCode|("iOS Designer", "1.0")]  
 		partial void dialogBackground_TouchUpInside (UIButton sender);  
  
 		void ReleaseDesignerOutlets ()  
 		{  
 			if (btnClose != null) {  
 				btnClose.Dispose ();  
 				btnClose = null;  
 			}  
 			if (dailogBackground != null) {  
 				dailogBackground.Dispose ();  
 				dailogBackground = null;  
 			}  
 			if (longPressDailog != null) {  
 				longPressDailog.Dispose ();  
 				longPressDailog = null;  
 			}  
 			if (tbvLongPressOptions != null) {  
 				tbvLongPressOptions.Dispose ();  
 				tbvLongPressOptions = null;  
 			}  
 		}  
 	}  
 }  
  
 </code>

====CurrentLocationPopup.cs====

<code csharp>   
 using CoreGraphics;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.iOSEdition;  
 using UIKit;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the location popup which display the location information.  
     /// </summary>  
     public class CurrentLocationPopup : Popup  
     {  
         private UILabel lblLocation;  
         private string content;  
  
         public CurrentLocationPopup(PointShape position, string content)  
             : base(position)  
         {  
             UIView view = new UIView(new CGRect(0, 0, 200, 45));  
             lblLocation = new UILabel(new CGRect(5, 5, 165, 40));  
             lblLocation.LineBreakMode = UILineBreakMode.WordWrap;  
             lblLocation.Lines = 2;  
             lblLocation.Font = UIFont.FromName("Arial", 16);  
             Content = content;  
  
             UIButton popupClose = UIButton.FromType(UIButtonType.System);  
             popupClose.Frame = new CGRect(170, 10, 30, 30);  
             popupClose.SetImage(UIImage.FromBundle("close_noborder"), UIControlState.Normal);  
             popupClose.TintColor = UIColor.Black;  
             popupClose.Layer.CornerRadius = 15;  
             popupClose.Layer.BorderWidth = 2;  
             popupClose.Layer.BorderColor = UIColor.Black.CGColor;  
             popupClose.TouchUpInside += (s, e1) => Hidden = true;  
  
             view.Add(lblLocation);  
             view.Add(popupClose);  
             ContentView.Add(view);  
         }  
  
         public string Content  
         {  
             get { return content; }  
             set  
             {  
                 content = value;  
                 lblLocation.Text = content;  
             }  
         }  
     }  
 }  
 </code>

====InstructionView.cs====

<code csharp>   
 using CoreGraphics;  
 using System;  
 using UIKit;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the toolbar instruction view for the MapView.  
     /// </summary>  
     internal class InstructionView : UIView  
     {  
         private nfloat fullHeight;  
         private UIView containerView;  
         private Action<CGRect, bool> instructionViewTopChanged;  
         private Action<UIView> resetChildrenLayout;  
  
         public InstructionView(UIView containerView, Action<UIView> resetChildrenLayout, Action<CGRect, bool> instructionViewTopChanged)  
         {  
             this.containerView = containerView;  
             this.resetChildrenLayout = resetChildrenLayout;  
             this.instructionViewTopChanged = instructionViewTopChanged;  
  
             ResetChildrenLayout();  
         }  
  
         private static int DescriptionMarginLeft  
         {  
             get  
             {  
                 return iOSCapabilityHelper.IsOnIPhone ? 10 : 20;  
             }  
         }  
  
         private void CollapseButton_TouchDown(object sender, EventArgs e)  
         {  
             nfloat barHeight = fullHeight - Frame.Height;  
             UIView.Animate(.2, () =>  
             {  
                 CGPoint upperLeft = new CGPoint(0, Frame.Bottom - barHeight);  
                 CGSize size = new CGSize(Frame.Width, barHeight);  
                 Frame = new CGRect(upperLeft, size);  
             });  
  
             instructionViewTopChanged(Frame, true);  
         }  
  
         private void ResetChildrenLayout()  
         {  
             UIInterfaceOrientation orientation = UIApplication.SharedApplication.StatusBarOrientation;  
             nfloat titleHeight = 40;  
             nfloat instructionHeight = orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight ? 50 : 90;  
             Frame = new CGRect(0, containerView.Bounds.Bottom - instructionHeight, containerView.Bounds.Width, instructionHeight);  
  
             Alpha = 0.6f;  
             BackgroundColor = UIColor.FromRGBA(126, 124, 129, 255);  
             fullHeight = Frame.Height + titleHeight;  
  
             UIView topLine = new UIView(new CGRect(0, 0, Frame.Width, 2));  
             topLine.BackgroundColor = UIColor.DarkGray;  
             topLine.Layer.CornerRadius = 4;  
             topLine.Layer.ShadowRadius = 3;  
             topLine.Layer.ShadowOpacity = .8f;  
             topLine.Layer.ShadowColor = UIColor.Black.CGColor;  
             topLine.Layer.ShadowOffset = new CGSize(1, 0);  
  
             UIView contentView;  
  
             UILabel instructionLabel = new UILabel();  
             instructionLabel.BackgroundColor = BackgroundColor;  
             instructionLabel.Text = "Getting Started";  
             instructionLabel.Font = UIFont.FromName("Helvetica-Bold", 20);  
             instructionLabel.TextColor = UIColor.White;  
             instructionLabel.ShadowColor = UIColor.Gray;  
             instructionLabel.ShadowOffset = new CGSize(1, 1);  
             instructionLabel.TextAlignment = UITextAlignment.Left;  
             Add(instructionLabel);  
  
             if (orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight)  
             {  
                 instructionLabel.Frame = new CGRect(DescriptionMarginLeft, 5, 160, titleHeight);  
  
                 contentView = new UIView(new CGRect(DescriptionMarginLeft, 10, Frame.Width - 2 * DescriptionMarginLeft,  
                         Frame.Height));  
             }  
             else  
             {  
                 UIButton collapseButton = UIButton.FromType(UIButtonType.RoundedRect);  
                 collapseButton.Frame = new CGRect(new CGPoint(Frame.Width - 60, 10), new CGSize(55, 30));  
                 collapseButton.SetImage(UIImage.FromBundle("More"), UIControlState.Normal);  
                 collapseButton.TintColor = UIColor.White;  
                 collapseButton.TouchUpInside += CollapseButton_TouchDown;  
  
                 instructionLabel.Frame = new CGRect(DescriptionMarginLeft, 0, Frame.Width, titleHeight);  
  
                 UIButton titleView = new UIButton();  
                 titleView.Frame = new CGRect(0, 0, Frame.Width, titleHeight);  
                 titleView.TouchUpInside += CollapseButton_TouchDown;  
                 titleView.Add(instructionLabel);  
                 titleView.Add(collapseButton);  
                 Add(titleView);  
  
                 nfloat contentViewTop = titleView.Frame.Bottom + 5;  
                 contentView = new UIView(new CGRect(DescriptionMarginLeft, contentViewTop, Frame.Width - 2 * DescriptionMarginLeft, Frame.Height - (contentViewTop)));  
             }  
             Add(topLine);  
             Add(contentView);  
             resetChildrenLayout(contentView);  
             instructionViewTopChanged(Frame, false);  
         }  
  
         internal void DidRotate()  
         {  
             foreach (var subview in Subviews)  
             {  
                 subview.RemoveFromSuperview();  
             }  
  
             ResetChildrenLayout();  
         }  
     }  
 }  
 </code>

====ScaleZoomLevelMapTool.cs====

<code csharp>   
 using CoreGraphics;  
 using System;  
 using System.Globalization;  
 using ThinkGeo.MapSuite.iOSEdition;  
 using UIKit;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the Scale/ZoomLevel we displayed on the map.  
     /// </summary>  
     public class ScaleZoomLevelMapTool : MapTool  
     {  
         private UILabel contentLabel;  
  
         public ScaleZoomLevelMapTool()  
         {  
             IsEnabled = true;  
             contentLabel = new UILabel();  
         }  
  
         protected override void InitializeCore(MapView mapView)  
         {  
             base.InitializeCore(mapView);  
             Frame = new CGRect(5, mapView.Frame.Bottom - 30, mapView.Frame.Width - 10, 30);  
             contentLabel.LineBreakMode = UILineBreakMode.WordWrap;  
             contentLabel.Lines = 2;  
             contentLabel.Font = UIFont.FromName("Arial", 12);  
             contentLabel.Frame = new CGRect(0, 0, Frame.Width, Frame.Height);  
             contentLabel.TextAlignment = UITextAlignment.Right;  
             AddSubview(contentLabel);  
  
             UpdateScaleContent(mapView.CurrentScale);  
             mapView.CurrentScaleChanged += MapView_CurrentExtentChanged;  
             mapView.AddSubview(this);  
         }  
  
         private void MapView_CurrentExtentChanged(object sender, CurrentScaleChangedMapViewEventArgs e)  
         {  
             UpdateScaleContent(e.NewScale);  
         }  
  
         private void UpdateScaleContent(double newScale = double.NaN)  
         {  
             if (!double.IsNaN(newScale))  
             {  
                 int zoomLevelIndex = CurrentMap.GetSnappedZoomLevelIndex(newScale);  
                 string textFormat = "Scale 1:{1:N0}  Zoom Level {0:N0}";  
                 contentLabel.Text = String.Format(CultureInfo.InvariantCulture, textFormat, zoomLevelIndex, newScale);  
             }  
             else  
             {  
                 contentLabel.Text = "Scale 1:--  Zoom Level --";  
             }  
         }  
     }  
 }  
 </code>

====TableViewRowClickEventArgs.cs====

<code csharp>   
 using Foundation;  
 using UIKit;  
 using System;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the TableViewRowClickEventArgs.  
     /// </summary>  
     public class TableViewRowClickEventArgs : EventArgs  
     {  
         private UITableView tableView;  
         private NSIndexPath indexPath;  
  
         public TableViewRowClickEventArgs(UITableView tableView, NSIndexPath indexPath)  
             : base()  
         {  
             this.tableView = tableView;  
             this.indexPath = indexPath;  
         }  
  
         public UITableView TableView  
         {  
             get { return tableView; }  
             set { tableView = value; }  
         }  
  
         public NSIndexPath IndexPath  
         {  
             get { return indexPath; }  
             set { indexPath = value; }  
         }  
     }  
 }  
 </code>

====TableViewSource.cs====

<code csharp>   
 using Foundation;  
 using UIKit;  
 using System;  
 using System.Collections.ObjectModel;  
  
 namespace GettingStartedSample  
 {  
     /// <summary>  
     /// This class represents the TableViewSource class.  
     /// </summary>  
     public class TableViewSource : UITableViewSource  
     {  
         private readonly Collection<SectionModel> sections;  
  
         public event EventHandler<TableViewRowClickEventArgs> RowClick;  
  
         public TableViewSource()  
         {  
             sections = new Collection<SectionModel>();  
         }  
  
         public Collection<SectionModel> Sections  
         {  
             get { return sections; }  
         }  
  
         public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)  
         {  
             CellModel currentModel = sections[indexPath.Section].Rows[indexPath.Row];  
  
             UITableViewCell cell = tableView.DequeueReusableCell("cell") ??  
                                    new UITableViewCell(UITableViewCellStyle.Subtitle, "Cell");  
  
             cell.Tag = indexPath.Row;  
             cell.TextLabel.Text = currentModel.Name;  
             cell.TextLabel.Font = UIFont.FromName("Arial", 13);  
  
             return cell;  
         }  
  
         public override nint NumberOfSections(UITableView tableView)  
         {  
             return sections.Count;  
         }  
  
         public override nint RowsInSection(UITableView tableview, nint section)  
         {  
             return sections[(int)section].Rows.Count;  
         }  
  
         public override void RowSelected(UITableView tableView, NSIndexPath indexPath)  
         {  
             EventHandler<TableViewRowClickEventArgs> handler = RowClick;  
             if (handler != null)  
             {  
                 handler(this, new TableViewRowClickEventArgs(tableView, indexPath));  
             }  
         }  
  
         public override nfloat GetHeightForRow(UITableView tableView, NSIndexPath indexPath)  
         {  
             return 30;  
         }  
     }  
  
     public class CellModel  
     {  
         private string name;  
  
         public CellModel(string name)  
         {  
             this.name = name;  
         }  
  
         public string Name  
         {  
             get { return name; }  
         }  
     }  
  
     public class SectionModel  
     {  
         private Collection<CellModel> rows;  
  
         public SectionModel()  
         {  
             rows = new Collection<CellModel>();  
         }  
  
         public Collection<CellModel> Rows  
         {  
             get { return rows; }  
         }  
     }  
 }  
 </code>

====AssemblyInfo.cs====

<code csharp>   
 using System.Reflection;  
 using System.Runtime.InteropServices;  
  
 // General Information about an assembly is controlled through the following  
 // set of attributes. Change these attribute values to modify the information  
 // associated with an assembly.  
 [assembly:|AssemblyTitle("GettingStartedSample")]  
 [assembly: AssemblyDescription("")]  
 [assembly:|AssemblyConfiguration("")]  
 [assembly: AssemblyCompany("")]  
 [assembly:|AssemblyProduct("GettingStartedSample")]  
 [assembly: AssemblyCopyright("Copyright ©  2015")]  
 [assembly:|AssemblyTrademark("")]  
 [assembly: AssemblyCulture("")]  
  
 // Setting ComVisible to false makes the types in this assembly not visible  
 // to COM components.  If you need to access a type in this assembly from  
 // COM, set the ComVisible attribute to true on that type.  
 [assembly:|ComVisible(false)]  
  
 // The following GUID is for the ID of the typelib if this project is exposed to COM  
 [assembly:|Guid("38e125d5-8180-4b44-9cff-100b569b69d5")]  
  
 // Version information for an assembly consists of the following four values:  
 //  
 //      Major Version  
 //      Minor Version  
 //      Build Number  
 //      Revision  
 //  
 // You can specify all the values or you can default the Build and Revision Numbers  
 // by using the '*' as shown below:  
 // [assembly:|AssemblyVersion("1.0.*")]  
 [assembly: AssemblyVersion("9.0.0.0")]  
 [assembly:|AssemblyFileVersion("9.0.0.0")]  
  
 </code>

====iOSCapabilityHelper.cs====

<code csharp>   
 using CoreGraphics;  
 using CoreLocation;  
 using System;  
 using UIKit;  
  
 namespace GettingStartedSample  
 {  
     internal static class iOSCapabilityHelper  
     {  
         private static Version currentSystemVersion;  
  
         public static Version CurrentSystemVersion  
         {  
             get  
             {  
                 return currentSystemVersion ?? (currentSystemVersion = Version.Parse(UIDevice.CurrentDevice.SystemVersion));  
             }  
         }  
  
         public static bool IsOnIPhone  
         {  
             get { return UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone; }  
         }  
  
         public static void SetViewLayout(UIView mainView)  
         {  
             if (CurrentSystemVersion.Major < 8)  
             {  
                 UIInterfaceOrientation statusBarOrientation = UIApplication.SharedApplication.StatusBarOrientation;  
                 if (statusBarOrientation == UIInterfaceOrientation.LandscapeLeft || statusBarOrientation == UIInterfaceOrientation.LandscapeRight)  
                 {  
                     mainView.Frame = new CGRect(0, 0, UIScreen.MainScreen.Bounds.Height, UIScreen.MainScreen.Bounds.Width);  
                 }  
                 else  
                 {  
                     mainView.Frame = UIScreen.MainScreen.Bounds;  
                 }  
             }  
         }  
  
         public static void SetGpsLocationManagerCapability(CLLocationManager locationManager)  
         {  
             if (CurrentSystemVersion.Major >= 8)  
             {  
                 // Add "NSLocationWhenInUseUsageDescription" and "NSLocationAlwaysUsageDescription" key into plist file.  
                 locationManager.RequestAlwaysAuthorization();  
                 locationManager.RequestWhenInUseAuthorization();  
             }  
         }  
     }  
 }  
 </code>