ThinkGeo Cloud
ThinkGeo UI Controls
ThinkGeo Open Source
Help and Support
External Resources
ThinkGeo Cloud
ThinkGeo UI Controls
ThinkGeo Open Source
Help and Support
External Resources
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(); } } }