using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class App : Application  
     {  
         public App()  
         {  
             InitializeStyles();  
             // The root page of your application  
             MainPage = new NavigationPage(new MainPage { Title = "Earthquake Statistics" });  
         }  
 
         protected override void OnStart()  
         {  
             // Handle when your app starts  
         }  
 
         protected override void OnSleep()  
         {  
             // Handle when your app sleeps  
         }  
 
         protected override void OnResume()  
         {  
             // Handle when your app resumes  
         }  
 
         private void InitializeStyles()  
         {  
             Application.Current.Resources = new ResourceDictionary();  
 
             Style headerStyle = new Style(typeof(ContentView));  
             headerStyle.Setters.Add(new Setter { Property = ContentView.PaddingProperty, Value = new Thickness(5, Device.OnPlatform(38, 5, 0), 5, 0) });  
             Application.Current.Resources.Add("ListHeaderStyle", headerStyle);  
 
             Style settingsContainerStyle = new Style(typeof(Grid));  
             settingsContainerStyle.Setters.Add(new Setter { Property = Grid.BackgroundColorProperty, Value = Color.FromHex("#efefef") });  
             settingsContainerStyle.Setters.Add(new Setter { Property = Grid.PaddingProperty, Value = new Thickness(0, 5, 0, 5) });  
             Application.Current.Resources.Add("SettingsContainerStyle", settingsContainerStyle);  
 
             Style settingsListLabelStyle = new Style(typeof(Label));  
             settingsListLabelStyle.Setters.Add(new Setter { Property = Label.TextColorProperty, Value = Color.Black });  
             settingsListLabelStyle.Setters.Add(new Setter { Property = Label.VerticalOptionsProperty, Value = LayoutOptions.End });  
             Application.Current.Resources.Add("SettingsListLabelStyle", settingsListLabelStyle);  
 
             Style sampleButtonStyle = new Style(typeof(Button));  
             sampleButtonStyle.Setters.Add(new Setter { Property = Button.BackgroundColorProperty, Value = Color.FromHex("#e0e0e0") });  
             sampleButtonStyle.Setters.Add(new Setter { Property = Button.TextColorProperty, Value = Color.FromHex("#000000") });  
             Application.Current.Resources.Add("SampleButtonStyle", sampleButtonStyle);  
 
             Style settingsContentStyle = new Style(typeof(Grid));  
             settingsContentStyle.Setters.Add(new Setter { Property = Grid.BackgroundColorProperty, Value = Color.White });  
             settingsContentStyle.Setters.Add(new Setter { Property = Grid.PaddingProperty, Value = new Thickness(5) });  
             Application.Current.Resources.Add("SettingsContentStyle", settingsContentStyle);  
 
             Style settingsTitleStyle = new Style(typeof(Label));  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.TextColorProperty, Value = Color.Black });  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.FontSizeProperty, Value = 21 });  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.FontAttributesProperty, Value = FontAttributes.Bold });  
             Application.Current.Resources.Add("SettingsTitleStyle", settingsTitleStyle);  
 
             Style settingsListGridStyle = new Style(typeof(Grid));  
             settingsListGridStyle.Setters.Add(new Setter { Property = Grid.PaddingProperty, Value = new Thickness(5, 0, 5, 0) });  
             Application.Current.Resources.Add("SettingsListGridStyle", settingsListGridStyle);  
 
             Style settingsListLineStyle = new Style(typeof(Grid));  
             settingsListLineStyle.Setters.Add(new Setter { Property = Grid.BackgroundColorProperty, Value = Device.OnPlatform(Color.Transparent, Color.Black, Color.Transparent) });  
             Application.Current.Resources.Add("SettingsListLineStyle", settingsListLineStyle);  
         }  
     }  
 }  
 
 

 using EarthquakeStatistics.Properties;  
 using System;  
 using System.Collections.ObjectModel;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class MainPageViewModel  
     {  
         private OperationMode operationMode;  
         private IPlatformService platformsService;  
 
         private MapView mapView;  
         private LayerOverlay highlightOverlay;  
         private LayerOverlay earthquakeOverlay;  
 
         private WorldMapKitOverlay wmkOverlay;  
         private OpenStreetMapOverlay osmOverlay;  
 
         private HeatLayer earthquakeHeatLayer;  
         private ShapeFileFeatureLayer earthquakePointLayer;  
         private InMemoryFeatureLayer selectedMarkerLayer;  
         private InMemoryFeatureLayer highlightMarkerLayer;  
 
         public MainPageViewModel(MapView mapControl)  
         {  
             this.mapView = mapControl;  
             this.platformsService = DependencyService.Get<IPlatformService>();  
 
             InitializeMapView();  
 
             SettingsPageViewModel.Instance.BaseMapTypeChanged += Instance_BaseMapTypeChanged;  
             SettingsPageViewModel.Instance.DisplayTypeChanged += Instance_DisplayTypeChanged;  
             SettingsPageViewModel.Instance.QueryButtonClicked += Instance_QueryButtonClicked;  
             SettingsPageViewModel.Instance.DisplayRestFeaturesButtonClicked += Instance_DisplayRestFeaturesButtonClicked;  
 
             MessagingCenter.Subscribe<SettingsPageViewModel, Feature>(SettingsPageViewModel.Instance, "CenterAt",  
                 (viewModel, feature) => { HighlightSelectedMarker(feature); mapView.CenterAt(feature); });  
             MessagingCenter.Subscribe<SettingsPageViewModel, Feature>(SettingsPageViewModel.Instance, "ZoomTo",  
                 (viewModel, feature) => { HighlightSelectedMarker(feature); mapView.ZoomTo(feature); });  
         }  
 
         public OperationMode OperationMode  
         {  
             get { return operationMode; }  
             set  
             {  
                 if (operationMode != value)  
                 {  
                     operationMode = value;  
 
                     switch (operationMode)  
                     {  
                         case OperationMode.Pan:  
                             mapView.TrackOverlay.TrackMode = TrackMode.None;  
                             break;  
                         case OperationMode.Polygon:  
                             mapView.TrackOverlay.TrackMode = TrackMode.Polygon;  
                             break;  
                         case OperationMode.Rectangle:  
                             mapView.TrackOverlay.TrackMode = TrackMode.Rectangle;  
                             break;  
                         default: break;  
                     }  
 
                     OnPropertyChanged(() => OperationMode);  
                 }  
             }  
         }  
 
         private void Instance_DisplayRestFeaturesButtonClicked(object sender, EventArgs e)  
         {  
             SettingsPageViewModel.Instance.QueriedEarthquakeItems.SafeClear();  
             foreach (Feature feature in selectedMarkerLayer.InternalFeatures)  
             {  
                 SettingsPageViewModel.Instance.QueriedEarthquakeItems.Add(new EarthquakeFeatureItem(feature));  
             }  
         }  
 
         private void Instance_QueryButtonClicked(object sender, EventArgs e)  
         {  
             Collection<Feature> filterResultFeatures = SettingsPageViewModel.Instance.FilterSelectedEarthquakeFeatures(SettingsPageViewModel.Instance.GetBackupQueriedFeatures());  
 
             selectedMarkerLayer.InternalFeatures.Clear();  
             highlightMarkerLayer.InternalFeatures.Clear();  
             SettingsPageViewModel.Instance.QueriedEarthquakeItems.SafeClear();  
 
             SettingsPageViewModel.Instance.QueriedEarthquakeItemsCount = filterResultFeatures.Count;  
             int i = 0;  
             foreach (Feature feature in filterResultFeatures)  
             {  
                 selectedMarkerLayer.InternalFeatures.Add(feature);  
                 if (i < 10) SettingsPageViewModel.Instance.QueriedEarthquakeItems.Add(new EarthquakeFeatureItem(feature));  
                 i++;  
             }  
             highlightOverlay.Refresh();  
         }  
 
         private void Instance_BaseMapTypeChanged(object sender, EventArgs e)  
         {  
             switch (SettingsPageViewModel.Instance.BaseMapType)  
             {  
                 case BaseMapType.WorldMapKitRoad:  
                     osmOverlay.IsVisible = false;  
                     wmkOverlay.IsVisible = true;  
                     wmkOverlay.MapType = WorldMapKitMapType.Road;  
                     break;  
                 case BaseMapType.WorldMapKitAerial:  
                     osmOverlay.IsVisible = false;  
                     wmkOverlay.IsVisible = true;  
                     wmkOverlay.MapType = WorldMapKitMapType.Aerial;  
                     break;  
                 case BaseMapType.WorldMapKitAerialWithLabels:  
                     osmOverlay.IsVisible = false;  
                     wmkOverlay.IsVisible = true;  
                     wmkOverlay.MapType = WorldMapKitMapType.AerialWithLabels;  
                     break;  
                 case BaseMapType.OpenStreetMap:  
                     osmOverlay.IsVisible = true;  
                     wmkOverlay.IsVisible = false;  
                     break;  
                 default:  
                     break;  
             }  
             mapView.Refresh();  
         }  
 
         private void Instance_DisplayTypeChanged(object sender, EventArgs e)  
         {  
             earthquakeOverlay = mapView.Overlays[Resources.EarthquakeOverlayKey] as LayerOverlay;  
             earthquakePointLayer = earthquakeOverlay.Layers[Resources.EarthquakePointLayerKey] as ShapeFileFeatureLayer;  
             earthquakeHeatLayer = earthquakeOverlay.Layers[Resources.EarthquakeHeatLayerKey] as HeatLayer;  
 
             earthquakePointLayer.IsVisible = false;  
             earthquakeHeatLayer.IsVisible = false;  
             switch (SettingsPageViewModel.Instance.DisplayType)  
             {  
                 case DisplayType.HeatMap:  
                     earthquakeHeatLayer.IsVisible = true;  
                     break;  
                 case DisplayType.Points:  
                     earthquakePointLayer.IsVisible = true;  
                     break;  
             }  
             mapView.Refresh();  
         }  
 
         private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)  
         {  
             MultipolygonShape resultShape = PolygonShape.Union(mapView.TrackOverlay.TrackShapeLayer.InternalFeatures);  
 
             FeatureLayer featureLayer = earthquakePointLayer;  
             if (!featureLayer.IsOpen)  
             { featureLayer.Open(); }  
 
             InMemoryFeatureSource source = new InMemoryFeatureSource(featureLayer.FeatureSource.GetColumns(), featureLayer.FeatureSource.GetFeaturesInsideBoundingBox(resultShape.GetBoundingBox(), ReturningColumnsType.AllColumns));  
             source.Open();  
 
             Collection<Feature> features = source.GetFeaturesWithinDistanceOf(new Feature(resultShape), mapView.MapUnit, DistanceUnit.Meter, 0.0001, ReturningColumnsType.AllColumns);  
 
             SettingsPageViewModel.Instance.BackupQueriedFeatures(features);  
             Collection<Feature> filterResultFeatures = SettingsPageViewModel.Instance.FilterSelectedEarthquakeFeatures(features);  
 
             selectedMarkerLayer.InternalFeatures.Clear();  
             foreach (Feature feature in filterResultFeatures)  
             {  
                 selectedMarkerLayer.InternalFeatures.Add(feature);  
             }  
             highlightOverlay.Refresh();  
         }  
 
         private void HighlightSelectedMarker(Feature feature)  
         {  
             highlightMarkerLayer.InternalFeatures.Clear();  
             highlightMarkerLayer.InternalFeatures.Add(feature);  
             highlightOverlay.Refresh();  
         }  
 
         private void ClearQueryResult()  
         {  
             selectedMarkerLayer.InternalFeatures.Clear();  
             highlightMarkerLayer.InternalFeatures.Clear();  
             mapView.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();  
 
             highlightOverlay.Refresh();  
             mapView.TrackOverlay.Refresh();  
 
             SettingsPageViewModel.Instance.QueriedEarthquakeItems.SafeClear();  
             SettingsPageViewModel.Instance.ClearBackupQueriedFeatures();  
         }  
 
         private void InitializeMapView()  
         {  
             ManagedProj4Projection proj4 = GetWgs84ToMercatorProjection();  
 
             // WMK  
             wmkOverlay = new WorldMapKitOverlay();  
             wmkOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
 
             // OSM  
             osmOverlay = new OpenStreetMapOverlay();  
             osmOverlay.TileCache = platformsService.GetOverlayTileCache(osmOverlay);  
             osmOverlay.IsVisible = false;  
 
             // Earthquake points  
             earthquakePointLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("usEarthquake.shp"));  
             earthquakePointLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Red, 5, GeoColor.SimpleColors.White, 1));  
             earthquakePointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             earthquakePointLayer.FeatureSource.Projection = proj4;  
 
             FeatureSource earthquakeHeatFeatureSource = new ShapeFileFeatureSource(SampleHelper.GetDataPath("usEarthquake_Simplified.shp"));  
             earthquakeHeatFeatureSource.Projection = proj4;  
 
             earthquakeHeatLayer = new HeatLayer(earthquakeHeatFeatureSource);  
             earthquakeHeatLayer.HeatStyle = new HeatStyle(10, 75, DistanceUnit.Kilometer);  
             earthquakeHeatLayer.HeatStyle.Alpha = 180;  
             earthquakeHeatLayer.IsVisible = false;  
 
             earthquakeOverlay = new LayerOverlay();  
             earthquakeOverlay.Layers.Add(Resources.EarthquakePointLayerKey, earthquakePointLayer);  
             earthquakeOverlay.Layers.Add(Resources.EarthquakeHeatLayerKey, earthquakeHeatLayer);  
 
             // Highlighted points  
             selectedMarkerLayer = new InMemoryFeatureLayer();  
             selectedMarkerLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Orange, 8, GeoColor.SimpleColors.White, 2);  
             selectedMarkerLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             PointStyle highLightMarkerStyle = new PointStyle();  
             highLightMarkerStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(50, GeoColor.SimpleColors.Blue), 20, GeoColor.SimpleColors.LightBlue, 1));  
             highLightMarkerStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(255, 0, 122, 255), 10, GeoColor.SimpleColors.White, 2));  
 
             highlightMarkerLayer = new InMemoryFeatureLayer();  
             highlightMarkerLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = highLightMarkerStyle;  
             highlightMarkerLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             highlightOverlay = new LayerOverlay();  
             highlightOverlay.Layers.Add(Resources.SelectMarkerLayerKey, selectedMarkerLayer);  
             highlightOverlay.Layers.Add(Resources.HighlightMarkerLayerKey, highlightMarkerLayer);  
 
             // Maps  
             mapView.MapUnit = GeographyUnit.Meter;  
             mapView.MapTools.ZoomMapTool.IsEnabled = false;  
             mapView.ZoomLevelSet = new BingMapsZoomLevelSet();  
             mapView.CurrentExtent = new RectangleShape(-19062735.6816748, 9273256.52450252, -5746827.16371793, 2673516.56066139);  
             mapView.BackgroundColor = Color.FromRgba(244, 242, 238, 255);  
 
             mapView.Overlays.Add(Resources.WorldMapKitOverlayKey, wmkOverlay);  
             mapView.Overlays.Add(Resources.OpenStreetMapOverlayKey, osmOverlay);  
             mapView.Overlays.Add(Resources.EarthquakeOverlayKey, earthquakeOverlay);  
             mapView.Overlays.Add(Resources.HighlightOverlayKey, highlightOverlay);  
 
             mapView.TrackOverlay.TrackShapeLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Clear();  
             mapView.TrackOverlay.TrackShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(80, GeoColor.SimpleColors.LightGreen), 8);  
             mapView.TrackOverlay.TrackShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.SimpleColors.White, 3, true);  
             mapView.TrackOverlay.TrackShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.FromArgb(80, GeoColor.SimpleColors.LightGreen), GeoColor.SimpleColors.White, 2);  
             mapView.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;  
         }  
 
         private static ManagedProj4Projection GetWgs84ToMercatorProjection()  
         {  
             ManagedProj4Projection wgs84ToMercatorProjection = new ManagedProj4Projection();  
             wgs84ToMercatorProjection.InternalProjectionParametersString = ManagedProj4Projection.GetWgs84ParametersString();  
             wgs84ToMercatorProjection.ExternalProjectionParametersString = ManagedProj4Projection.GetBingMapParametersString();  
             return wgs84ToMercatorProjection;  
         }  
     }  
 }  
 
 

 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class MainPageViewModel : ViewModelBase  
     {  
         private Command clearCommand;  
         private Command queryCommand;  
         private Command panCommand;  
         private Command polygonCommand;  
         private Command settingsCommand;  
         private Command rectangleCommand;  
 
         public Command SettingsCommand  
         {  
             get  
             {  
                 settingsCommand = settingsCommand ?? new Command(() =>  
                 {  
                     mapView.Navigation.PushAsync(SettingsPage.Instance, true);  
                 });  
 
                 return settingsCommand;  
             }  
         }  
 
         public Command PolygonCommand  
         {  
             get  
             {  
                 polygonCommand = polygonCommand ?? new Command(() => OperationMode = OperationMode.Polygon);  
                 return polygonCommand;  
             }  
         }  
 
         public Command PanCommand  
         {  
             get  
             {  
                 panCommand = panCommand ?? new Command(() => OperationMode = OperationMode.Pan);  
                 return panCommand;  
             }  
         }  
 
         public Command RectangleCommand  
         {  
             get  
             {  
                 rectangleCommand = rectangleCommand ?? new Command(() => OperationMode = OperationMode.Rectangle);  
                 return rectangleCommand;  
             }  
         }  
 
         public Command ClearCommand  
         {  
             get  
             {  
                 clearCommand = clearCommand ?? new Command(() => { ClearQueryResult(); });  
                 return clearCommand;  
             }  
         }  
 
         public Command QueryCommand  
         {  
             get  
             {  
                 queryCommand = queryCommand ?? new Command(async () =>  
                 {  
                     SettingsPageViewModel.Instance.QueriedEarthquakeItemsCount = selectedMarkerLayer.InternalFeatures.Count;  
                     SettingsPageViewModel.Instance.QueriedEarthquakeItems.SafeClear();  
                     foreach (Feature feature in selectedMarkerLayer.InternalFeatures.Take(10))  
                     {  
                         SettingsPageViewModel.Instance.QueriedEarthquakeItems.Add(new EarthquakeFeatureItem(feature));  
                     }  
 
                     QueryConfigurationPage queryPage = new QueryConfigurationPage();  
                     queryPage.ToolbarItems.Add(new ToolbarItem("? Back", "quit", () => { queryPage.Navigation.PopAsync(true); }));  
 
                     await mapView.Navigation.PushAsync(queryPage, false);  
                 });  
                 return queryCommand;  
             }  
         }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class MainPage : ContentPage  
     {  
         public MainPage()  
         {  
             InitializeComponent();  
 
             MapView mapView = new MapView();  
             mapContainer.Content = mapView;  
 
             BindingContext = new MainPageViewModel(mapView);  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class BaseMapTypeToNameConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             if (value is BaseMapType)  
             {  
                 BaseMapType settingType = (BaseMapType)value;  
                 switch (settingType)  
                 {  
                     case BaseMapType.WorldMapKitRoad: return "World Map Kit Road";  
                     case BaseMapType.WorldMapKitAerial: return "World Map Kit Aerial";  
                     case BaseMapType.WorldMapKitAerialWithLabels: return "World Map Kit Aerial With Labels";  
                     case BaseMapType.OpenStreetMap: return "Open Street Map";  
                 }  
             }  
             else  
             {  
                 BaseMapType mapType;  
                 string baseMapTypeString = value.ToString().Replace(" ", "");  
                 if (Enum.TryParse(baseMapTypeString, true, out mapType))  
                     return mapType;  
             }  
 
             return null;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             return Convert(value, targetType, parameter, culture);  
         }  
     }  
 }  
 
 

 using System;  
 using System.Collections;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class CollectionToBooleanConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             ICollection collection = (ICollection)value;  
             return collection.Count != SettingsPageViewModel.Instance.QueriedEarthquakeItemsCount;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             throw new NotImplementedException();  
         }  
     }  
 }  
 
 

 using System;  
 using System.Collections;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class CollectionToCountConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             string result = string.Empty;  
             ICollection collection = (ICollection)value;  
             if (parameter == null)  
             {  
                 result = collection.Count.ToString();  
             }  
             else if (parameter.Equals("REST"))  
             {  
                 result = (SettingsPageViewModel.Instance.QueriedEarthquakeItemsCount - collection.Count).ToString();  
             }  
             return result;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             throw new NotImplementedException();  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class DisplayTypeToNameConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             if (value is DisplayType)  
             {  
                 DisplayType displayType = (DisplayType)value;  
                 switch (displayType)  
                 {  
                     case DisplayType.HeatMap: return "Heat Style";  
                     case DisplayType.Points: return "Point Style";  
                 }  
             }  
             else  
             {  
                 switch (value.ToString())  
                 {  
                     case "Heat Style": return DisplayType.HeatMap;  
                     case "Point Style": return DisplayType.Points;  
                 }  
             }  
 
             return null;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             return Convert(value, targetType, parameter, culture);  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class EarthquakeItemToTextConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             EarthquakeFeatureItem item = (EarthquakeFeatureItem)value;  
 
             string result = string.Empty;  
 
             if (parameter != null)  
             {  
                 if (parameter.Equals("INFO"))  
                 {  
                     result = string.Format("{0} ({1:0.00}, {2:0.00})", item.Location, item.Longitude, item.Latitude);  
                 }  
                 else if (parameter.Equals("DESCRIPTION"))  
                 {  
                     result = string.Format("year: {0}; magnitude: {1}; depth: {2} km.", item.Date, item.Magnitude, item.Depth);  
                 }  
             }  
 
             return result;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             throw new NotImplementedException();  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class OperationModeToImageSourceConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             string operationParameter = (string)parameter;  
             if (value is OperationMode)  
             {  
                 OperationMode operationMode = (OperationMode)value;  
                 switch (operationMode)  
                 {  
                     case OperationMode.Polygon:  
                         if (operationParameter.Equals("POLYGON", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_polygon_check.png", "draw_polygon_check", string.Empty) };  
                         }  
                         else if (operationParameter.Equals("PAN", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/panicon.png", "panicon", string.Empty) };  
                         }  
                         else  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_Rectangle.png", "draw_Rectangle", string.Empty) };  
                         }  
                     case OperationMode.Pan:  
                         if (operationParameter.Equals("PAN", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/panicon_check.png", "panicon_check", string.Empty) };  
                         }  
                         else if (operationParameter.Equals("POLYGON", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_polygon.png", "draw_polygon", string.Empty) };  
                         }  
                         else  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_Rectangle.png", "draw_Rectangle", string.Empty) };  
                         }  
                     case OperationMode.Rectangle:  
                     default:  
                         if (operationParameter.Equals("PAN", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/panicon.png", "panicon", string.Empty) };  
                         }  
                         else if (operationParameter.Equals("POLYGON", StringComparison.OrdinalIgnoreCase))  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_polygon.png", "draw_polygon", string.Empty) };  
                         }  
                         else  
                         {  
                             return new FileImageSource { File = Device.OnPlatform("Icons/draw_Rectangle_check.png", "draw_Rectangle_check", string.Empty) };  
                         }  
                         break;  
                 }  
             }  
 
             return null;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             throw new NotImplementedException();  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class SettingsTypeToNameConverter : IValueConverter  
     {  
         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             if (value is SettingType)  
             {  
                 SettingType settingType = (SettingType)value;  
                 switch (settingType)  
                 {  
                     case SettingType.BaseMap: return "Base Map";  
                     case SettingType.DisplayType: return "Display Type";  
                     case SettingType.Magnitude: return "Magnitude";  
                     case SettingType.DepthOfHypocenter: return "Depth of Hypocenter(Km)";  
                     case SettingType.Date: return "Date(Year)";  
                 }  
             }  
             else  
             {  
                 switch (value.ToString())  
                 {  
                     case "Base Map": return SettingType.BaseMap;  
                     case "Display Type": return SettingType.DisplayType;  
                     case "Magnitude": return SettingType.Magnitude;  
                     case "Depth of Hypocenter(Km)": return SettingType.DepthOfHypocenter;  
                     case "Date(Year)": return SettingType.Date;  
                 }  
             }  
 
             return null;  
         }  
 
         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
         {  
             return Convert(value, targetType, parameter, culture);  
         }  
     }  
 }  
 
 

 
 namespace EarthquakeStatistics  
 {  
     public enum BaseMapType  
     {  
         WorldMapKitRoad = 0,  
         WorldMapKitAerial = 1,  
         WorldMapKitAerialWithLabels = 2,  
         OpenStreetMap = 3,  
     }  
 }  
 
 

 namespace EarthquakeStatistics  
 {  
     public enum DisplayType  
     {  
         Points=0,  
         HeatMap=1  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class EarthquakeFeatureItem  
     {  
         private static ManagedProj4Projection wgs84ToMercatorProjection;  
 
         private Feature feature;  
         private string location;  
         private Command<Feature> searchSiteCommand;  
         private double longitude, latitude;  
         private double date, depth, magnitude;  
 
         public EarthquakeFeatureItem(Feature feature)  
         {  
             this.feature = feature;  
 
             if (double.TryParse(feature.ColumnValues["LONGITUDE"], out longitude) && double.TryParse(feature.ColumnValues["LATITIUDE"], out latitude))  
             {  
                 PointShape point = new PointShape(longitude, latitude);  
                 point = (PointShape)Wgs84ToMercatorProjection.ConvertToInternalProjection(point);  
                 longitude = point.X;  
                 latitude = point.Y;  
             }  
 
             location = feature.ColumnValues["LOCATION"];  
             double.TryParse(feature.ColumnValues["MAGNITUDE"], out magnitude);  
             double.TryParse(feature.ColumnValues["DEPTH_KM"], out depth);  
             double.TryParse(feature.ColumnValues["YEAR"], out date);  
         }  
 
         public double Latitude  
         {  
             get { return latitude; }  
         }  
 
         public double Longitude  
         {  
             get { return longitude; }  
         }  
 
         public double Magnitude  
         {  
             get { return magnitude; }  
         }  
 
         public double Depth  
         {  
             get { return depth; }  
         }  
 
         public double Date  
         {  
             get { return date; }  
         }  
 
         public string Location  
         {  
             get { return location; }  
         }  
 
         public Feature Feature  
         {  
             get { return feature; }  
             set { feature = value; }  
         }  
 
         private static ManagedProj4Projection Wgs84ToMercatorProjection  
         {  
             get  
             {  
                 wgs84ToMercatorProjection = wgs84ToMercatorProjection ?? new ManagedProj4Projection()  
                 {  
                     InternalProjectionParametersString = ManagedProj4Projection.GetWgs84ParametersString(),  
                     ExternalProjectionParametersString = ManagedProj4Projection.GetBingMapParametersString()  
                 };  
 
                 wgs84ToMercatorProjection.Open();  
                 return wgs84ToMercatorProjection;  
             }  
         }  
     }  
 }  
 
 

 
 namespace EarthquakeStatistics  
 {  
     public enum OperationMode  
     {  
         Pan = 0,  
         Polygon = 1,  
         Rectangle = 2  
     }  
 }  
 
 

 
 namespace EarthquakeStatistics  
 {  
     public enum SettingType  
     {  
         BaseMap = 0,  
         DisplayType = 1,  
         Magnitude = 2,  
         DepthOfHypocenter = 3,  
         Date = 4  
     }  
 }  
 
 

 using System.Resources;  
 using System.Reflection;  
 
 // 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("EarthquakeStatistics")]  
 [assembly: AssemblyDescription("")]  
 [assembly:|AssemblyConfiguration("")]  
 [assembly: AssemblyCompany("")]  
 [assembly:|AssemblyProduct("EarthquakeStatistics")]  
 [assembly: AssemblyCopyright("Copyright ©  2015")]  
 [assembly:|AssemblyTrademark("")]  
 [assembly: AssemblyCulture("")]  
 [assembly:|NeutralResourcesLanguage("en")]  
 
 // 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("1.0.0.0")]  
 [assembly:|AssemblyFileVersion("1.0.0.0")]  
 
 

 //------------------------------------------------------------------------------  
 // <auto-generated>  
 //     This code was generated by a tool.  
 //     Runtime Version:4.0.30319.34014  
 //  
 //     Changes to this file may cause incorrect behavior and will be lost if  
 //     the code is regenerated.  
 // </auto-generated>  
 //------------------------------------------------------------------------------  
 
 namespace EarthquakeStatistics.Properties {  
     using System.Reflection;  
 
 
     /// <summary>  
     ///   A strongly-typed resource class, for looking up localized strings, etc.  
     /// </summary>  
     // This class was auto-generated by the StronglyTypedResourceBuilder  
     // class via a tool like ResGen or Visual Studio.  
     // To add or remove a member, edit your .ResX file then rerun ResGen  
     // with the /str option, or rebuild your VS project.  
     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder",|"4.0.0.0")]  
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]  
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]  
     internal class Resources {  
 
         private static global::System.Resources.ResourceManager resourceMan;  
 
         private static global::System.Globalization.CultureInfo resourceCulture;  
 
         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance",|"CA1811:AvoidUncalledPrivateCode")]  
         internal Resources() {  
         }  
 
         /// <summary>  
         ///   Returns the cached ResourceManager instance used by this class.  
         /// </summary>  
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]  
         internal static global::System.Resources.ResourceManager ResourceManager {  
             get {  
                 if (object.ReferenceEquals(resourceMan, null)) {  
                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("EarthquakeStatistics.Properties.Resources", typeof(Resources).GetTypeInfo().Assembly);  
                     resourceMan = temp;  
                 }  
                 return resourceMan;  
             }  
         }  
 
         /// <summary>  
         ///   Overrides the current thread's CurrentUICulture property for all  
         ///   resource lookups using this strongly typed resource class.  
         /// </summary>  
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]  
         internal static global::System.Globalization.CultureInfo Culture {  
             get {  
                 return resourceCulture;  
             }  
             set {  
                 resourceCulture = value;  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Earthquake Heat Layer.  
         /// </summary>  
         internal static string EarthquakeHeatLayerKey {  
             get {  
                 return ResourceManager.GetString("EarthquakeHeatLayerKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Earthquake Overlay.  
         /// </summary>  
         internal static string EarthquakeOverlayKey {  
             get {  
                 return ResourceManager.GetString("EarthquakeOverlayKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Earthquake Point Layer.  
         /// </summary>  
         internal static string EarthquakePointLayerKey {  
             get {  
                 return ResourceManager.GetString("EarthquakePointLayerKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Highlight Marker Layer.  
         /// </summary>  
         internal static string HighlightMarkerLayerKey {  
             get {  
                 return ResourceManager.GetString("HighlightMarkerLayerKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Highlight Overlay.  
         /// </summary>  
         internal static string HighlightOverlayKey {  
             get {  
                 return ResourceManager.GetString("HighlightOverlayKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Open Street Map.  
         /// </summary>  
         internal static string OpenStreetMapOverlayKey {  
             get {  
                 return ResourceManager.GetString("OpenStreetMapOverlayKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to Select Marker Layer.  
         /// </summary>  
         internal static string SelectMarkerLayerKey {  
             get {  
                 return ResourceManager.GetString("SelectMarkerLayerKey", resourceCulture);  
             }  
         }  
 
         /// <summary>  
         ///   Looks up a localized string similar to World Map Kit.  
         /// </summary>  
         internal static string WorldMapKitOverlayKey {  
             get {  
                 return ResourceManager.GetString("WorldMapKitOverlayKey", resourceCulture);  
             }  
         }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace EarthquakeStatistics  
 {  
     public interface IPlatformService  
     {  
         BitmapTileCache GetOverlayTileCache(TileOverlay tileOverlay);  
     }  
 }  
 
 

 using System.Collections.ObjectModel;  
 using System.IO;  
 using System.Linq;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public static class SampleHelper  
     {  
         public static string GetDataPath(string fileName)  
         {  
             string result = string.IsNullOrEmpty(SampleDataDictionary) ? Path.Combine(AssetsDataDictionary, fileName)  
                 : Path.Combine(SampleDataDictionary, AssetsDataDictionary, fileName);  
             return result;  
         }  
 
         public static string SampleDataDictionary  
         {  
             get { return Device.OnPlatform(string.Empty, @"mnt/sdcard/MapSuiteSampleData/EarthquakeStatistics", string.Empty); }  
         }  
 
         public static string AssetsDataDictionary  
         {  
             get { return Device.OnPlatform("AppData", "AppData", string.Empty); }  
         }  
 
         public static void SafeClear<T>(this ObservableCollection<T> items)  
         {  
             while (items.Any())  
             {  
                 items.RemoveAt(0);  
             }  
         }  
     }  
 }  
 
 

 
 namespace EarthquakeStatistics  
 {  
     public class SettingItem : ViewModelBase  
     {  
         private string title;  
         private SettingType settingType;  
 
         public SettingItem(SettingType settingType, string title)  
         {  
             SettingType = settingType;  
             Value = title;  
         }  
 
         public SettingType SettingType  
         {  
             get { return settingType; }  
             set { settingType = value; OnPropertyChanged(() => SettingType); }  
         }  
 
         public string Value  
         {  
             get { return title; }  
             set { title = value; OnPropertyChanged(() => Value); }  
         }  
     }  
 }  
 
 

 using System;  
 using System.Collections.ObjectModel;  
 using System.Collections.Specialized;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public class SettingsPageViewModel : ViewModelBase  
     {  
         public event EventHandler QueryButtonClicked;  
         public event EventHandler BaseMapTypeChanged;  
         public event EventHandler DisplayTypeChanged;  
         public event EventHandler DisplayRestFeaturesButtonClicked;  
 
         private BaseMapType baseMapType;  
         private SettingItem selectedItem;  
         private Command queryCommand;  
         private Command displayMoreCommand;  
         private SettingItem selectedQuerySettingItem;  
         private Collection<BaseMapType> baseMapTypes;  
         private DisplayType displayType;  
         private Collection<DisplayType> displayTypes;  
         private ObservableCollection<SettingItem> settingItems;  
         private ObservableCollection<SettingItem> querySettingItems;  
         private ObservableCollection<EarthquakeFeatureItem> queriedEarthquakeItems;  
         private int magnitudeFromValue, magnitudeToValue;  
         private int depthFromValue, depthToValue;  
         private int dateFromValue, dateToValue;  
         private int queriedEarthquakeItemsCount;  
         private GeoCollection<Feature> backupQueriedFeatures;  
 
         private static SettingsPageViewModel instance;  
 
         protected SettingsPageViewModel()  
         {  
             backupQueriedFeatures = new GeoCollection<Feature>();  
 
             magnitudeFromValue = 0;  
             magnitudeToValue = 12;  
             depthFromValue = 0;  
             depthToValue = 300;  
             dateFromValue = 1568;  
             dateToValue = 2010;  
 
             QueriedEarthquakeItems.CollectionChanged += QueriedEarthquakeItems_CollectionChanged;  
         }  
 
         public static SettingsPageViewModel Instance  
         {  
             get  
             {  
                 instance = instance ?? new SettingsPageViewModel();  
                 return instance;  
             }  
         }  
 
         public Collection<BaseMapType> BaseMapTypes  
         {  
             get  
             {  
                 baseMapTypes = baseMapTypes ?? new Collection<BaseMapType>(Enum.GetValues(typeof(BaseMapType)).Cast<BaseMapType>().ToList());  
                 return baseMapTypes;  
             }  
         }  
 
         public Collection<DisplayType> DisplayTypes  
         {  
             get  
             {  
                 displayTypes = displayTypes ?? new Collection<DisplayType>(Enum.GetValues(typeof(DisplayType)).Cast<DisplayType>().ToList());  
                 return displayTypes;  
             }  
         }  
 
         public ObservableCollection<SettingItem> SettingItems  
         {  
             get  
             {  
                 settingItems = settingItems ?? new ObservableCollection<SettingItem>  
                 {  
                     new SettingItem(SettingType.BaseMap, "World Map Kit"),  
                     new SettingItem(SettingType.DisplayType, "Points"),  
                 };  
                 return settingItems;  
             }  
         }  
 
         public ObservableCollection<SettingItem> QuerySettingItems  
         {  
             get  
             {  
                 querySettingItems = querySettingItems ?? new ObservableCollection<SettingItem> {  
                     new SettingItem(SettingType.Magnitude, "0 to 12"),  
                     new SettingItem(SettingType.DepthOfHypocenter, "0 to 300"),  
                     new SettingItem(SettingType.Date, "1568 to 2010")  
                 };  
 
                 foreach (SettingItem item in querySettingItems)  
                 {  
                     switch (item.SettingType)  
                     {  
                         case SettingType.DepthOfHypocenter:  
                             item.Value = string.Format("{0} to {1}", DepthFromValue, DepthToValue);  
                             break;  
                         case SettingType.Magnitude:  
                             item.Value = string.Format("{0} to {1}", MagnitudeFromValue, MagnitudeToValue);  
                             break;  
                         case SettingType.Date:  
                             item.Value = string.Format("{0} to {1}", DateFromValue, DateToValue);  
                             break;  
                         default: break;  
                     }  
                 }  
 
                 return querySettingItems;  
             }  
         }  
 
         public SettingItem SelectedItem  
         {  
             get { return selectedItem; }  
             set  
             {  
                 selectedItem = value;  
                 OnPropertyChanged(() => SelectedItem);  
             }  
         }  
 
         public SettingItem SelectedQuerySettingItem  
         {  
             get { return selectedQuerySettingItem; }  
             set  
             {  
                 selectedQuerySettingItem = value;  
                 OnPropertyChanged(() => SelectedQuerySettingItem);  
             }  
         }  
 
         public int MagnitudeFromValue  
         {  
             get { return magnitudeFromValue; }  
             set  
             {  
                 magnitudeFromValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int MagnitudeToValue  
         {  
             get { return magnitudeToValue; }  
             set  
             {  
                 magnitudeToValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int DepthFromValue  
         {  
             get { return depthFromValue; }  
             set  
             {  
                 depthFromValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int DepthToValue  
         {  
             get { return depthToValue; }  
             set  
             {  
                 depthToValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int DateFromValue  
         {  
             get { return dateFromValue; }  
             set  
             {  
                 dateFromValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int DateToValue  
         {  
             get { return dateToValue; }  
             set  
             {  
                 dateToValue = value;  
                 OnPropertyChanged(() => QuerySettingItems);  
             }  
         }  
 
         public int QueriedEarthquakeItemsCount  
         {  
             get { return queriedEarthquakeItemsCount; }  
             set  
             {  
                 queriedEarthquakeItemsCount = value;  
                 OnPropertyChanged(() => QueriedEarthquakeItemsCount);  
             }  
         }  
 
         public BaseMapType BaseMapType  
         {  
             get { return baseMapType; }  
             set  
             {  
                 if (baseMapType != value)  
                 {  
                     baseMapType = value;  
                     OnBaseMapTypeChanged();  
                     OnPropertyChanged(() => BaseMapType);  
                 }  
             }  
         }  
 
         public DisplayType DisplayType  
         {  
             get { return displayType; }  
             set  
             {  
                 if (displayType != value)  
                 {  
                     displayType = value;  
                     OnDisplayTypeChanged();  
                     OnPropertyChanged(() => DisplayType);  
                 }  
                 displayType = value;  
             }  
         }  
 
         public Command QueryCommand  
         {  
             get  
             {  
                 queryCommand = queryCommand ?? new Command(() =>  
                 {  
                     OnQueryButtonClicked();  
                 });  
                 return queryCommand;  
             }  
         }  
 
         public Command DisplayMoreCommand  
         {  
             get  
             {  
                 displayMoreCommand = displayMoreCommand ?? new Command(() =>  
                 {  
                     OnDisplayRestFeaturesButtonClicked();  
                 });  
                 return displayMoreCommand;  
             }  
         }  
 
         public ObservableCollection<EarthquakeFeatureItem> QueriedEarthquakeItems  
         {  
             get  
             {  
                 queriedEarthquakeItems = queriedEarthquakeItems ?? new ObservableCollection<EarthquakeFeatureItem>();  
                 return queriedEarthquakeItems;  
             }  
         }  
 
         private void QueriedEarthquakeItems_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)  
         {  
             OnPropertyChanged(() => QueriedEarthquakeItems);  
         }  
 
         public void BackupQueriedFeatures(Collection<Feature> features)  
         {  
             backupQueriedFeatures.Clear();  
 
             foreach (Feature feature in features)  
             {  
                 backupQueriedFeatures.Add(feature);  
             }  
         }  
 
         public void ClearBackupQueriedFeatures()  
         {  
             backupQueriedFeatures.Clear();  
         }  
 
         public Collection<Feature> GetBackupQueriedFeatures()  
         {  
             return new Collection<Feature>(backupQueriedFeatures);  
         }  
 
         public Collection<Feature> FilterSelectedEarthquakeFeatures(Collection<Feature> features)  
         {  
             Collection<Feature> filterResultFeatures = new Collection<Feature>();  
             foreach (var feature in features)  
             {  
                 double year, depth, magnitude;  
                 double.TryParse(feature.ColumnValues["MAGNITUDE"], out magnitude);  
                 double.TryParse(feature.ColumnValues["DEPTH_KM"], out depth);  
                 double.TryParse(feature.ColumnValues["YEAR"], out year);  
 
                 if ((magnitude >= magnitudeFromValue && magnitude <= magnitudeToValue || magnitude == -9999)  
                        && (depth <= depthToValue && depth >= depthFromValue || depth == -9999)  
                        && (year >= dateFromValue && year <= dateToValue) || year == -9999)  
                 {  
                     filterResultFeatures.Add(feature);  
                 }  
             }  
 
             return filterResultFeatures;  
         }  
 
         protected virtual void OnDisplayTypeChanged()  
         {  
             EventHandler handler = DisplayTypeChanged;  
 
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
 
         protected virtual void OnBaseMapTypeChanged()  
         {  
             EventHandler handler = BaseMapTypeChanged;  
 
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
 
         protected virtual void OnQueryButtonClicked()  
         {  
             EventHandler handler = QueryButtonClicked;  
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
 
         protected virtual void OnDisplayRestFeaturesButtonClicked()  
         {  
             EventHandler handler = DisplayRestFeaturesButtonClicked;  
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
     }  
 }  
 

 using System;  
 using System.ComponentModel;  
 using System.Linq.Expressions;  
 
 namespace EarthquakeStatistics  
 {  
     public abstract class ViewModelBase : INotifyPropertyChanged  
     {  
         public event PropertyChangedEventHandler PropertyChanged;  
 
         protected void OnPropertyChanged<T>(Expression<Func<T>> exp)  
         {  
             PropertyChangedEventHandler handler = PropertyChanged;  
             if (handler != null)  
             {  
                 string propertyName = ((MemberExpression)exp.Body).Member.Name;  
                 handler(this, new PropertyChangedEventArgs(propertyName));  
             }  
         }  
     }  
 }  
 
 

 using System.Globalization;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class BaseMapsPage : ContentPage  
     {  
         private static BaseMapTypeToNameConverter nameConverter = new BaseMapTypeToNameConverter();  
 
         public BaseMapsPage()  
         {  
             InitializeComponent();  
             BindingContext = SettingsPageViewModel.Instance;  
 
             ToolbarItems.Add(new ToolbarItem("? Back", "quit", () => { Navigation.PopAsync(true); }));  
         }  
 
         private void BaseMapTypeList_ItemTapped(object sender, ItemTappedEventArgs e)  
         {  
             BaseMapType baseMapType = SettingsPageViewModel.Instance.BaseMapType;  
             SettingsPageViewModel.Instance.SettingItems[0].Value = nameConverter.Convert(baseMapType, typeof(BaseMapType), null, CultureInfo.InvariantCulture).ToString();  
 
             Navigation.PopAsync(true);  
         }  
     }  
 }  
 
 

 using System.Globalization;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class DisplayTypePage : ContentPage  
     {  
         private static DisplayTypeToNameConverter nameConverter = new DisplayTypeToNameConverter();  
 
         public DisplayTypePage()  
         {  
             InitializeComponent();  
             BindingContext = SettingsPageViewModel.Instance;  
 
             ToolbarItems.Add(new ToolbarItem("? Back", "quit", () => { Navigation.PopAsync(true); }));  
         }  
 
         private void DisplayTypeList_ItemTapped(object sender, ItemTappedEventArgs e)  
         {  
             DisplayType displayType = SettingsPageViewModel.Instance.DisplayType;  
             SettingsPageViewModel.Instance.SettingItems[1].Value = nameConverter.Convert(displayType, typeof(DisplayType), null, CultureInfo.InvariantCulture).ToString();  
 
             Navigation.PopAsync(true);  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class QueryConfigurationPage : ContentPage  
     {  
         private SettingType settingType;  
 
         public QueryConfigurationPage()  
         {  
             InitializeComponent();  
             BindingContext = SettingsPageViewModel.Instance;  
         }  
 
         private async void QueriedEarthquakeItems_ItemTapped(object sender, ItemTappedEventArgs e)  
         {  
             string action = await Application.Current.MainPage.DisplayActionSheet("Options", "Cancel", null, new string[] { "Center at", "Zoom to" });  
             EarthquakeFeatureItem earthquakeFeatureItem = (EarthquakeFeatureItem)e.Item;  
 
             if (action == "Center at")  
             {  
                 await Navigation.PopAsync(true);  
                 MessagingCenter.Send<SettingsPageViewModel, Feature>(SettingsPageViewModel.Instance, "CenterAt", earthquakeFeatureItem.Feature);  
             }  
             else if (action == "Zoom to")  
             {  
                 await Navigation.PopAsync(true);  
                 MessagingCenter.Send<SettingsPageViewModel, Feature>(SettingsPageViewModel.Instance, "ZoomTo", earthquakeFeatureItem.Feature);  
             }  
         }  
 
         private void QuerySettingItems_ItemTapped(object sender, ItemTappedEventArgs e)  
         {  
             QuerySettingValuesPage querySettingValuesPage = new QuerySettingValuesPage();  
             SettingItem settingItem = (SettingItem)e.Item;  
             settingType = settingItem.SettingType;  
             switch (settingItem.SettingType)  
             {  
                 case SettingType.DepthOfHypocenter:  
                     querySettingValuesPage.Title = "Depth Of Hypocenter Settings";  
                     for (int i = 0; i <= 300; i++) querySettingValuesPage.Values.Add(i);  
                     querySettingValuesPage.RefreshQueryItems(SettingsPageViewModel.Instance.DepthFromValue, SettingsPageViewModel.Instance.DepthToValue);  
                     break;  
                 case SettingType.Magnitude:  
                     querySettingValuesPage.Title = "Magnitude Settings";  
                     for (int i = 0; i <= 12; i++) querySettingValuesPage.Values.Add(i);  
                     querySettingValuesPage.RefreshQueryItems(SettingsPageViewModel.Instance.MagnitudeFromValue, SettingsPageViewModel.Instance.MagnitudeToValue);  
                     break;  
                 default:  
                 case SettingType.Date:  
                     querySettingValuesPage.Title = "Date Settings";  
                     for (int i = 1568; i <= 2010; i++) querySettingValuesPage.Values.Add(i);  
                     querySettingValuesPage.RefreshQueryItems(SettingsPageViewModel.Instance.DateFromValue, SettingsPageViewModel.Instance.DateToValue);  
                     break;  
             }  
 
             querySettingValuesPage.FinishedSettings += querySettingValuesPage_FinishedSettings;  
             Navigation.PushAsync(querySettingValuesPage, true);  
         }  
 
         private void querySettingValuesPage_FinishedSettings(object sender, EventArgs e)  
         {  
             QuerySettingValuesPage querySettingValuesPage = (QuerySettingValuesPage)sender;  
             switch (settingType)  
             {  
                 case SettingType.DepthOfHypocenter:  
                     SettingsPageViewModel.Instance.DepthFromValue = querySettingValuesPage.FromValue;  
                     SettingsPageViewModel.Instance.DepthToValue = querySettingValuesPage.ToValue;  
                     break;  
                 case SettingType.Magnitude:  
                     SettingsPageViewModel.Instance.MagnitudeFromValue = querySettingValuesPage.FromValue;  
                     SettingsPageViewModel.Instance.MagnitudeToValue = querySettingValuesPage.ToValue;  
                     break;  
                 default:  
                 case SettingType.Date:  
                     SettingsPageViewModel.Instance.DateFromValue = querySettingValuesPage.FromValue;  
                     SettingsPageViewModel.Instance.DateToValue = querySettingValuesPage.ToValue;  
                     break;  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using System.Collections.Generic;  
 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class QuerySettingValuesPage : ContentPage  
     {  
         public event EventHandler FinishedSettings;  
 
         private int toValue;  
         private int fromValue;  
         private List<int> values;  
 
         public QuerySettingValuesPage()  
         {  
             InitializeComponent();  
 
             fromValuePicker.SelectedIndexChanged += fromValuePicker_SelectedIndexChanged;  
             toValuePicker.SelectedIndexChanged += toValuePicker_SelectedIndexChanged;  
         }  
 
         public int ToValue  
         {  
             get { return toValue; }  
         }  
 
         public int FromValue  
         {  
             get { return fromValue; }  
         }  
 
         public List<int> Values  
         {  
             get { return values ?? (values = new List<int>()); }  
         }  
 
         public void RefreshQueryItems(int defaultFromValue, int defaultToValue)  
         {  
             foreach (int value in Values)  
             {  
                 fromValuePicker.Items.Add(value.ToString());  
                 toValuePicker.Items.Add(value.ToString());  
             }  
 
             toValuePicker.SelectedIndex = Values.IndexOf(defaultToValue);  
             fromValuePicker.SelectedIndex = Values.IndexOf(defaultFromValue);  
         }  
 
         private void OkButtton_Clicked(object sender, EventArgs e)  
         {  
             Navigation.PopAsync(true);  
             OnFinishedSettings();  
         }  
 
         private void CancelButtton_Clicked(object sender, EventArgs e)  
         {  
             Navigation.PopAsync(true);  
         }  
 
         private void fromValuePicker_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             int newFromValue = int.Parse(fromValuePicker.Items[fromValuePicker.SelectedIndex]);  
             if (newFromValue > toValue)  
             {  
                 newFromValue = fromValue;  
                 fromValuePicker.SelectedIndex = Values.IndexOf(newFromValue);  
                 Application.Current.MainPage.DisplayAlert("Error", "Please select a new from-value, it must less than to-value.", "OK");  
             }  
 
             fromValue = newFromValue;  
         }  
 
         private void toValuePicker_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             int newToValue = int.Parse(toValuePicker.Items[toValuePicker.SelectedIndex]);  
             if (newToValue < fromValue)  
             {  
                 newToValue = toValue;  
                 toValuePicker.SelectedIndex = Values.IndexOf(newToValue);  
                 Application.Current.MainPage.DisplayAlert("Error", "Please select a new to-value, it must greater than from-value.", "OK");  
             }  
 
             toValue = newToValue;  
         }  
 
         protected virtual void OnFinishedSettings()  
         {  
             EventHandler handler = FinishedSettings;  
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
     }  
 }  
 
 

 using Xamarin.Forms;  
 
 namespace EarthquakeStatistics  
 {  
     public partial class SettingsPage : ContentPage  
     {  
         private static SettingsPage instance;  
 
         protected SettingsPage()  
         {  
             InitializeComponent();  
             BindingContext = SettingsPageViewModel.Instance;  
             ToolbarItems.Add(new ToolbarItem("? Back", "quit", () => { Navigation.PopAsync(true); }));  
         }  
 
         public static SettingsPage Instance  
         {  
             get  
             {  
                 instance = instance ?? new SettingsPage();  
                 return instance;  
             }  
         }  
 
         private void SettingList_ItemTapped(object sender, ItemTappedEventArgs e)  
         {  
             SettingItem tappedItem = (SettingItem)e.Item;  
             switch (tappedItem.SettingType)  
             {  
                 case SettingType.BaseMap:  
                     Navigation.PushAsync(new BaseMapsPage(), true);  
                     break;  
                 case SettingType.DisplayType:  
                     Navigation.PushAsync(new DisplayTypePage(), true);  
                     break;  
                 default:  
                     break;  
             }  
         }  
 
         protected override void OnDisappearing()  
         {  
             base.OnDisappearing();  
         }  
     }  
 }