User Tools

Site Tools

Trace: • source_code_androideditionsample_geometricfunctions.zip

Sidebar

ThinkGeo Cloud

ThinkGeo UI Controls

ThinkGeo Open Source

Help and Support

External Resources

source_code_androideditionsample_geometricfunctions.zip

Table of Contents

Source Code AndroidEditionSample GeometricFunctions.zip

MainActivity.cs

 using Android.App;  
 using Android.Content;  
 using Android.OS;  
 using Android.Widget;  
 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Globalization;  
 using System.IO;  
 using System.Linq;  
 using System.Reflection;  
 using System.Xml.Linq;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     [Activity(Label = "Geometric Func", Icon = "@drawable/icon", ConfigurationChanges = Android.Content.PM.ConfigChanges.Orientation | Android.Content.PM.ConfigChanges.KeyboardHidden | Android.Content.PM.ConfigChanges.ScreenSize)]  
     public class MainActivity : Activity  
     {  
         private ListView listView;  
         private SliderView sliderView;  
         private BaseSample activitySample;  
         private Collection<BaseSample> samples;  
         private List<Tuple<string, int>> listItems;  
 
         protected override void OnCreate(Bundle bundle)  
         {  
             base.OnCreate(bundle);  
             SetContentView(Resource.Layout.Main);  
 
             ActionBar.Hide();  
             listView = FindViewById<ListView>(Resource.Id.sampleListView);  
             sliderView = (SliderView)FindViewById(Resource.Id.slider_view);  
             ImageButton helpButton = FindViewById<ImageButton>(Resource.Id.sampleListMoreButton);  
 
             InitializeSmapleListView();  
             activitySample = samples.FirstOrDefault();  
             sliderView.MainView.AddView(samples.FirstOrDefault().GetSampleView());  
             helpButton.Click += delegate  
             {  
                 Intent helpIntent = new Intent(Intent.ActionView, Android.Net.Uri.Parse("http://www.thinkgeo.com"));  
                 StartActivity(helpIntent);  
             };  
         }  
 
         private void InitializeSmapleListView()  
         {  
             samples = new Collection<BaseSample>();  
             listItems = new List<Tuple<string, int>>();  
             XDocument xDoc = XDocument.Load(Assets.Open("GeometricFunctions.xml"));  
             if (xDoc.Root != null)  
             {  
                 foreach (var element in xDoc.Root.Elements())  
                 {  
                     string image = element.Attribute("Image").Value;  
                     string className = element.Attribute("Class").Value;  
                     string name = element.Attribute("Name").Value;  
                     XElement geometrySourceElement = element.Element("GeometrySource");  
 
                     BaseSample sample = (BaseSample)Activator.CreateInstance(Assembly.GetExecutingAssembly().GetType("GeometricFunctions." + className), this, sliderView);  
                     sample.TitleText = name;  
                     samples.Add(sample);  
 
                     foreach (var featureWktElement in geometrySourceElement.Elements())  
                     {  
                         if (!string.IsNullOrEmpty(featureWktElement.Value))  
                         {  
                             sample.GeometrySource.Add(new Feature(featureWktElement.Value));  
                         }  
                     }  
 
                     int resouceId = (int)typeof(Resource.Drawable).GetField(image).GetValue(null);  
                     listItems.Add(new Tuple<string, int>(name, resouceId));  
                 }  
             }  
             ActivityListItemAdapter adapter = new ActivityListItemAdapter(this, listItems);  
             listView.Adapter = adapter;  
             listView.ItemClick += sampleListView_ItemClick;  
         }  
 
         private void sampleListView_ItemClick(object sender, AdapterView.ItemClickEventArgs e)  
         {  
             sliderView.SetSlided(false);  
 
             activitySample.DisposeMap();  
             sliderView.MainView.RemoveAllViews();  
             sliderView.MainView.AddView(samples[e.Position].GetSampleView());  
             activitySample = samples[e.Position];  
         }  
     }  
 }  
 

SplashActivity.cs

 using Android.App;  
 using Android.OS;  
 using Android.Widget;  
 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.IO;  
 using System.Linq;  
 using System.Threading.Tasks;  
 
 namespace GeometricFunctions  
 {  
     [Activity(Theme = "@android:style/Theme.Light.NoTitleBar", MainLauncher = true, NoHistory = true, ScreenOrientation = Android.Content.PM.ScreenOrientation.Portrait,  
         ConfigurationChanges = Android.Content.PM.ConfigChanges.Orientation | Android.Content.PM.ConfigChanges.KeyboardHidden |  
         Android.Content.PM.ConfigChanges.ScreenSize)]  
     public class SplashActivity : Activity  
     {  
         private TextView uploadTextView;  
         private ProgressBar uploadProgressBar;  
 
         protected override void OnCreate(Bundle savedInstanceState)  
         {  
             base.OnCreate(savedInstanceState);  
             SetContentView(Resource.Layout.SplashLayout);  
 
             uploadTextView = FindViewById<TextView>(Resource.Id.uploadDataTextView);  
             uploadProgressBar = FindViewById<ProgressBar>(Resource.Id.uploadProgressBar);  
 
             Task updateSampleDatasTask = Task.Factory.StartNew(() =>  
             {  
                 Collection<string> unLoadDatas = CollectUnloadDatas(SampleHelper.SampleDataDictionary, SampleHelper.AssetsDataDictionary);  
                 UploadDataFiles(SampleHelper.SampleDataDictionary, unLoadDatas, OnCopyingSourceFile);  
 
                 uploadTextView.Post(() =>  
                 {  
                     uploadTextView.Text = "Ready";  
                     uploadProgressBar.Progress = 100;  
                 });  
             });  
 
             updateSampleDatasTask.ContinueWith(t =>  
             {  
                 uploadTextView.PostDelayed(() =>  
                 {  
                     StartActivity(typeof(MainActivity));  
                     Finish();  
                 }, 200);  
             });  
         }  
 
         private void OnCopyingSourceFile(string targetPathFilename, int completeCount, int totalCount)  
         {  
             uploadTextView.Post(() =>  
             {  
                 uploadTextView.Text = string.Format("Copying {0} ({1}/{2})", Path.GetFileName(targetPathFilename), completeCount, totalCount);  
                 uploadProgressBar.Progress = (int)(completeCount * 100f / totalCount);  
             });  
         }  
 
         private Collection<string> CollectUnloadDatas(string targetDirectory, string sourceDirectory)  
         {  
             Collection<string> result = new Collection<string>();  
 
             foreach (string filename in Assets.List(sourceDirectory))  
             {  
                 string sourcePath = System.IO.Path.Combine(sourceDirectory, filename);  
                 string targetPath = System.IO.Path.Combine(targetDirectory, sourcePath);  
 
                 bool isSourcePathAFile = !string.IsNullOrEmpty(Path.GetExtension(sourcePath));  
                 if (isSourcePathAFile && !File.Exists(targetPath))  
                 {  
                     result.Add(sourcePath);  
                 }  
                 else if (!isSourcePathAFile)  
                 {  
                     foreach (string item in CollectUnloadDatas(targetDirectory, sourcePath))  
                     {  
                         result.Add(item);  
                     }  
                 }  
             }  
             return result;  
         }  
 
         private void UploadDataFiles(string targetDirectory, IEnumerable<string> sourcePathFilenames, Action<string, int, int> onCopyingSourceFile = null)  
         {  
             int completeCount = 0;  
             if (!Directory.Exists(targetDirectory)) Directory.CreateDirectory(targetDirectory);  
 
             foreach (string sourcePathFilename in sourcePathFilenames)  
             {  
                 string targetPathFilename = Path.Combine(targetDirectory, sourcePathFilename);  
                 if (!File.Exists(targetPathFilename))  
                 {  
                     if (onCopyingSourceFile != null) onCopyingSourceFile(targetPathFilename, completeCount, sourcePathFilenames.Count());  
 
                     string targetPath = Path.GetDirectoryName(targetPathFilename);  
                     if (!Directory.Exists(targetPath)) Directory.CreateDirectory(targetPath);  
                     Stream sourceStream = Assets.Open(sourcePathFilename);  
                     FileStream fileStream = File.Create(targetPathFilename);  
                     sourceStream.CopyTo(fileStream);  
                     fileStream.Close();  
                     sourceStream.Close();  
 
                     completeCount++;  
                 }  
             }  
         }  
     }  
 }  
 

AssemblyInfo.cs

 using System.Reflection;  
 using System.Runtime.CompilerServices;  
 using System.Runtime.InteropServices;  
 using Android.App;  
 
 // 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("GeometricFunctions")]  
 [assembly: AssemblyDescription("")]  
 [assembly: AssemblyConfiguration("")]  
 [assembly: AssemblyCompany("")]  
 [assembly: AssemblyProduct("GeometricFunctions")]  
 [assembly: AssemblyCopyright("Copyright ©  2014")]  
 [assembly: AssemblyTrademark("")]  
 [assembly: AssemblyCulture("")]  
 [assembly: ComVisible(false)]  
 
 // 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")]  
 
 

Resource.Designer.cs

 #pragma warning disable 1591  
 //------------------------------------------------------------------------------  
 // <auto-generated>  
 //     This code was generated by a tool.  
 //     Runtime Version:4.0.30319.0  
 //  
 //     Changes to this file may cause incorrect behavior and will be lost if  
 //     the code is regenerated.  
 // </auto-generated>  
 //------------------------------------------------------------------------------  
 
 [assembly: global::Android.Runtime.ResourceDesignerAttribute("GeometricFunctions.Resource", IsApplication=true)]  
 
 namespace GeometricFunctions  
 {  
 
 
 	[System.CodeDom.Compiler.GeneratedCodeAttribute("Xamarin.Android.Build.Tasks", "1.0.0.0")]  
 	public partial class Resource  
 	{  
 
 		static Resource()  
 		{  
 			global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 		}  
 
 		public static void UpdateIdValues()  
 		{  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_default256x256 = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_default256x256;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_default512x512 = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_default512x512;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_globe = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_globe;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_globe_Pressed = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_globe_Pressed;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_Minus = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_Minus;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_Minus_Pressed = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_Minus_Pressed;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_noImageTile = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_noImageTile;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_Plus = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_Plus;  
 			global::ThinkGeo.MapSuite.AndroidEdition.Resource.Drawable.icon_mapsuite_Plus_Pressed = global::GeometricFunctions.Resource.Drawable.icon_mapsuite_Plus_Pressed;  
 		}  
 
 		public partial class Attribute  
 		{  
 
 			static Attribute()  
 			{  
 				global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 			}  
 
 			private Attribute()  
 			{  
 			}  
 		}  
 
 		public partial class Drawable  
 		{  
 
 			// aapt resource value: 0x7f020000  
 			public const int bbox = 2130837504;  
 
 			// aapt resource value: 0x7f020001  
 			public const int buffer = 2130837505;  
 
 			// aapt resource value: 0x7f020002  
 			public const int centerPoint = 2130837506;  
 
 			// aapt resource value: 0x7f020003  
 			public const int clip = 2130837507;  
 
 			// aapt resource value: 0x7f020004  
 			public const int convexHull = 2130837508;  
 
 			// aapt resource value: 0x7f020005  
 			public const int detail40 = 2130837509;  
 
 			// aapt resource value: 0x7f020006  
 			public const int difference = 2130837510;  
 
 			// aapt resource value: 0x7f020007  
 			public const int getArea = 2130837511;  
 
 			// aapt resource value: 0x7f020008  
 			public const int getLength = 2130837512;  
 
 			// aapt resource value: 0x7f020009  
 			public const int Icon = 2130837513;  
 
 			// aapt resource value: 0x7f02000a  
 			public const int icon_mapsuite_default256x256 = 2130837514;  
 
 			// aapt resource value: 0x7f02000b  
 			public const int icon_mapsuite_default512x512 = 2130837515;  
 
 			// aapt resource value: 0x7f02000c  
 			public const int icon_mapsuite_globe = 2130837516;  
 
 			// aapt resource value: 0x7f02000d  
 			public const int icon_mapsuite_globe_Pressed = 2130837517;  
 
 			// aapt resource value: 0x7f02000e  
 			public const int icon_mapsuite_Minus = 2130837518;  
 
 			// aapt resource value: 0x7f02000f  
 			public const int icon_mapsuite_Minus_Pressed = 2130837519;  
 
 			// aapt resource value: 0x7f020010  
 			public const int icon_mapsuite_noImageTile = 2130837520;  
 
 			// aapt resource value: 0x7f020011  
 			public const int icon_mapsuite_Plus = 2130837521;  
 
 			// aapt resource value: 0x7f020012  
 			public const int icon_mapsuite_Plus_Pressed = 2130837522;  
 
 			// aapt resource value: 0x7f020013  
 			public const int iconstyle = 2130837523;  
 
 			// aapt resource value: 0x7f020014  
 			public const int lineOnLine = 2130837524;  
 
 			// aapt resource value: 0x7f020015  
 			public const int MapSuite = 2130837525;  
 
 			// aapt resource value: 0x7f020016  
 			public const int More = 2130837526;  
 
 			// aapt resource value: 0x7f020017  
 			public const int more40 = 2130837527;  
 
 			// aapt resource value: 0x7f020018  
 			public const int rotate = 2130837528;  
 
 			// aapt resource value: 0x7f020019  
 			public const int scale = 2130837529;  
 
 			// aapt resource value: 0x7f02001a  
 			public const int settings40 = 2130837530;  
 
 			// aapt resource value: 0x7f02001b  
 			public const int shortestLine = 2130837531;  
 
 			// aapt resource value: 0x7f02001c  
 			public const int simplify = 2130837532;  
 
 			// aapt resource value: 0x7f02001d  
 			public const int SliderLineBackground = 2130837533;  
 
 			// aapt resource value: 0x7f02001e  
 			public const int snapGps = 2130837534;  
 
 			// aapt resource value: 0x7f02001f  
 			public const int union = 2130837535;  
 
 			static Drawable()  
 			{  
 				global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 			}  
 
 			private Drawable()  
 			{  
 			}  
 		}  
 
 		public partial class Id  
 		{  
 
 			// aapt resource value: 0x7f050008  
 			public const int ExecuteButton = 2131034120;  
 
 			// aapt resource value: 0x7f050005  
 			public const int LabelStylingLayout = 2131034117;  
 
 			// aapt resource value: 0x7f050009  
 			public const int MapContainerView = 2131034121;  
 
 			// aapt resource value: 0x7f050006  
 			public const int SampleListButton = 2131034118;  
 
 			// aapt resource value: 0x7f050007  
 			public const int TitleTextView = 2131034119;  
 
 			// aapt resource value: 0x7f050004  
 			public const int mainLinearLayout = 2131034116;  
 
 			// aapt resource value: 0x7f050003  
 			public const int sampleListMoreButton = 2131034115;  
 
 			// aapt resource value: 0x7f050001  
 			public const int sampleListTitle = 2131034113;  
 
 			// aapt resource value: 0x7f050002  
 			public const int sampleListView = 2131034114;  
 
 			// aapt resource value: 0x7f050000  
 			public const int slider_view = 2131034112;  
 
 			// aapt resource value: 0x7f05000b  
 			public const int uploadDataTextView = 2131034123;  
 
 			// aapt resource value: 0x7f05000a  
 			public const int uploadProgressBar = 2131034122;  
 
 			static Id()  
 			{  
 				global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 			}  
 
 			private Id()  
 			{  
 			}  
 		}  
 
 		public partial class Layout  
 		{  
 
 			// aapt resource value: 0x7f030000  
 			public const int ButtonBackgroundSelector = 2130903040;  
 
 			// aapt resource value: 0x7f030001  
 			public const int Main = 2130903041;  
 
 			// aapt resource value: 0x7f030002  
 			public const int SampleBaseLayout = 2130903042;  
 
 			// aapt resource value: 0x7f030003  
 			public const int SplashLayout = 2130903043;  
 
 			static Layout()  
 			{  
 				global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 			}  
 
 			private Layout()  
 			{  
 			}  
 		}  
 
 		public partial class String  
 		{  
 
 			// aapt resource value: 0x7f040001  
 			public const int ApplicationName = 2130968577;  
 
 			// aapt resource value: 0x7f040000  
 			public const int Hello = 2130968576;  
 
 			static String()  
 			{  
 				global::Android.Runtime.ResourceIdManager.UpdateIdValues();  
 			}  
 
 			private String()  
 			{  
 			}  
 		}  
 	}  
 }  
 #pragma warning restore 1591  
 
 

BufferSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class BufferSample : BaseSample  
     {  
         private int bufferSize;  
 
         public BufferSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer bufferedLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BufferedLayer"];  
 
             bufferSize += 15;  
             Feature bufferSourceFeature = sourceLayer.InternalFeatures[0].CloneDeep();  
             Feature bufferedFeature = bufferSourceFeature.Buffer(bufferSize, 8, BufferCapType.Butt, GeographyUnit.Meter, DistanceUnit.Meter);  
             bufferedLayer.InternalFeatures.Clear();  
             bufferedLayer.InternalFeatures.Add(bufferedFeature);  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             bufferSize = 0;  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer bufferedLayer = new InMemoryFeatureLayer();  
             bufferedLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(140, 255, 155, 13)));  
             bufferedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("BufferedLayer", bufferedLayer);  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

CenterPointSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class CenterPointSample : BaseSample  
     {  
         private ManagedProj4Projection projection;  
 
         public CenterPointSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer pointLayer = (InMemoryFeatureLayer)layerOverlay.Layers["PointLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();  
             pointLayer.Clear();  
             Feature centerFeature = new Feature(feature.GetBoundingBox().GetCenterPoint());  
             PointShape centerPoint = (PointShape)projection.ConvertToExternalProjection(centerFeature.CloneDeep()).GetShape();  
             centerFeature.ColumnValues["Type"] = string.Format("Center at Lon: {0:N4}, Lat: {1:N4}", centerPoint.X, centerPoint.Y);  
             pointLayer.InternalFeatures.Add(centerFeature);  
             Feature centroidFeature = new Feature(feature.GetShape().GetCenterPoint());  
             PointShape centroidPoint = (PointShape)projection.ConvertToExternalProjection(centroidFeature.CloneDeep()).GetShape();  
             centroidFeature.ColumnValues["Type"] = string.Format("Centroid at Lon: {0:N4}, Lat: {1:N4}", centroidPoint.X, centroidPoint.Y);  
             pointLayer.InternalFeatures.Add(centroidFeature);  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(20);  
             MapView.CurrentExtent = mapExtent;  
 
             projection = new ManagedProj4Projection();  
             projection.InternalProjectionParametersString = ManagedProj4Projection.GetSphericalMercatorParametersString();  
             projection.ExternalProjectionParametersString = ManagedProj4Projection.GetLatLongParametersString();  
             projection.Open();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();  
             pointLayer.Open();  
             pointLayer.Columns.Add(new FeatureSourceColumn("Type"));  
             pointLayer.Close();  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSize = 12;  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, 255, 155, 13), 2);  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSolidBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 255, 248, 172));  
             pointLayer.DrawingMarginPercentage = 100;  
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Type";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("PointLayer", pointLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

ClipSample.cs

 using Android.Content;  
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class ClipSample : BaseSample  
     {  
         public ClipSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer clipLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ClippingLayer"];  
             Feature clippingFeature = clipLayer.InternalFeatures.FirstOrDefault();  
 
             if (clippingFeature != null)  
             {  
                 sourceLayer.Open();  
                 Collection<Feature> features = sourceLayer.QueryTools.GetFeaturesIntersecting(clippingFeature.GetShape(), ReturningColumnsType.AllColumns);  
                 sourceLayer.InternalFeatures.Clear();  
                 clipLayer.InternalFeatures.Clear();  
                 foreach (Feature feature in features)  
                 {  
                     sourceLayer.InternalFeatures.Add(feature.GetIntersection(clippingFeature));  
                 }  
             }  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             foreach (Feature feature in GeometrySource.Skip(1))  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
 
             InMemoryFeatureLayer clippingLayer = new InMemoryFeatureLayer();  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);  
             clippingLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             clippingLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ClippingLayer", clippingLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

ConvexHullSample.cs

 using System.Linq;  
 using Android.Content;  
 using System.Collections.ObjectModel;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class ConvexHullSample : BaseSample  
     {  
         public ConvexHullSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer convexHullLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ConvexHullLayer"];  
 
             sourceLayer.Open();  
             Collection<Feature> features = sourceLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns);  
 
             convexHullLayer.Clear();  
             MultipointShape multipointShape = new MultipointShape();  
             foreach (Feature feature in features.Skip(1))  
             {  
                 PointShape pointShape = (PointShape)feature.GetShape();  
                 multipointShape.Points.Add(pointShape);  
             }  
 
             RingShape convexHull = multipointShape.ConvexHull();  
             PolygonShape polygonShape = new PolygonShape(convexHull);  
             convexHullLayer.InternalFeatures.Add(new Feature(polygonShape));  
             convexHullLayer.InternalFeatures.Add(features.FirstOrDefault().GetConvexHull());  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(SampleHelper.GetDataPath(@"fire.png"));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             foreach (Feature feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
 
             InMemoryFeatureLayer convexHullLayer = new InMemoryFeatureLayer();  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ConvexHullLayer", convexHullLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

DifferenceSample.cs

 using Android.Content;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class DifferenceSample : BaseSample  
     {  
         public DifferenceSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             if (sourceLayer.InternalFeatures.Count > 1)  
             {  
                 AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape2"].GetShape();  
                 AreaBaseShape targetShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape1"].GetShape();  
                 AreaBaseShape resultShape = sourceShape.GetDifference(targetShape);  
 
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(resultShape.GetWellKnownBinary()));  
 
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);  
             sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

EnvelopSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class EnvelopSample : BaseSample  
     {  
         public EnvelopSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer boundingboxLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BoundingboxLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             Feature sourceFeature = sourceLayer.InternalFeatures.First();  
             boundingboxLayer.InternalFeatures.Clear();  
             boundingboxLayer.InternalFeatures.Add(new Feature(sourceFeature.GetBoundingBox()));  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
 
             InMemoryFeatureLayer boundingboxLayer = new InMemoryFeatureLayer();  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("BoundingboxLayer", boundingboxLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

GetAreaSample.cs

 using Android.Content;  
 using Android.Widget;  
 using System.Globalization;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class GetAreaSample : BaseSample  
     {  
         private Context context;  
 
         public GetAreaSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         {  
             this.context = context;  
         }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (feature != null)  
             {  
                 AreaBaseShape areaShape = (AreaBaseShape)feature.GetShape();  
                 double metersArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.SquareMeters);  
                 double hectaresArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.Hectares);  
 
                 string areaMessage = string.Format(CultureInfo.InvariantCulture, "{0:N2} Hectares, \r\n {1:N2} Acres", metersArea, hectaresArea);  
                 feature.ColumnValues["Area"] = areaMessage;  
 
                 Toast.MakeText(context, areaMessage, ToastLength.Long).Show();  
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.Open();  
             sourceLayer.Columns.Add(new FeatureSourceColumn("Area"));  
 
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
 
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Area";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
 
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             GeometrySource.First().ColumnValues.Clear();  
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

GetLengthSample.cs

 using Android.Content;  
 using Android.Widget;  
 using System.Globalization;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class GetLengthSample : BaseSample  
     {  
         private Context context;  
 
         public GetLengthSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         {  
             this.context = context;  
         }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (firstFeature != null)  
             {  
                 Feature feature = firstFeature.CloneDeep();  
                 LineBaseShape lineShape = (LineBaseShape)feature.GetShape();  
                 double length = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile);  
                 string lengthContent = string.Format(CultureInfo.InvariantCulture, "Length is {0:N2} miles.", length);  
                 feature.ColumnValues["Length"] = lengthContent;  
 
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(feature);  
 
                 Toast.MakeText(context, lengthContent, ToastLength.Long).Show();  
 
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.Open();  
             sourceLayer.Columns.Add(new FeatureSourceColumn("Length"));  
             sourceLayer.Close();  
 
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Length";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
 
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.TileType = TileType.SingleTile;  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

GetShortestLineSample.cs

 using Android.Content;  
 using System.Globalization;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class GetShortestLineSample : BaseSample  
     {  
         public GetShortestLineSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer shortestLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ShortestLineLayer"];  
 
             BaseShape areaShape1 = sourceLayer.InternalFeatures["AreaShape1"].GetShape();  
             BaseShape areaShape2 = sourceLayer.InternalFeatures["AreaShape2"].GetShape();  
             MultilineShape multiLineShape = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter);  
             Feature feature = new Feature(multiLineShape.GetWellKnownBinary());  
             feature.ColumnValues["Distance"] = string.Format(CultureInfo.InvariantCulture, "Distance is {0:N2} miles.", multiLineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile));  
             shortestLineLayer.InternalFeatures.Clear();  
             shortestLineLayer.InternalFeatures.Add(feature);  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(20);  
             MapView.CurrentExtent = mapExtent;  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);  
             sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);  
 
             InMemoryFeatureLayer shortestLineLayer = new InMemoryFeatureLayer();  
             shortestLineLayer.Open();  
             shortestLineLayer.Columns.Add(new FeatureSourceColumn("Distance"));  
 
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Distance";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
 
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Width = 5;  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Color = GeoColor.FromArgb(180, 255, 155, 13);  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ShortestLineLayer", shortestLineLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

LineOnLineSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class LineOnLineSample : BaseSample  
     {  
         public LineOnLineSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer lineOnLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["LineOnLineLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (firstFeature != null)  
             {  
                 LineShape lineShape = (LineShape)firstFeature.GetShape();  
                 lineOnLineLayer.InternalFeatures.Clear();  
 
                 LineBaseShape resultLine = lineShape.GetLineOnALine(StartingPoint.FirstPoint, 80, 450, GeographyUnit.Meter, DistanceUnit.Meter);  
                 lineOnLineLayer.InternalFeatures.Add(new Feature(resultLine));  
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Circle, GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black, 18);  
             foreach (var feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
 
             InMemoryFeatureLayer lineOnLineLayer = new InMemoryFeatureLayer();  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Blue);  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Red);  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("LineOnLineLayer", lineOnLineLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

RotateSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class RotateSample : BaseSample  
     {  
         public RotateSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             Feature sourceFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (sourceFeature != null && sourceFeature.GetShape().CanRotate)  
             {  
                 PointShape center = sourceFeature.GetBoundingBox().GetCenterPoint();  
                 BaseShape rotatedShape = BaseShape.Rotate(sourceFeature.GetShape(), center, 22.5f);  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(rotatedShape));  
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

ScaleSample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class ScaleSample : BaseSample  
     {  
         public ScaleSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             Feature sourceFeature = sourceLayer.InternalFeatures.First();  
 
             sourceLayer.Open();  
             sourceLayer.EditTools.BeginTransaction();  
             sourceLayer.EditTools.ScaleUp(sourceFeature.Id, 10);  
             sourceLayer.EditTools.CommitTransaction();  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             Feature sourceFeature = GeometrySource.First();  
             sourceLayer.InternalFeatures.Add(sourceFeature.Id, sourceFeature);  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

SimplifySample.cs

 using Android.Content;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class SimplifySample : BaseSample  
     {  
         private static readonly double simplifyTolerence = 30;  
 
         public SimplifySample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures.FirstOrDefault().GetShape();  
             SimplificationType simplificationType = SimplificationType.DouglasPeucker;  
 
             MultipolygonShape multipolygonShape = sourceShape.Simplify(GeographyUnit.Meter, simplifyTolerence, DistanceUnit.Meter, simplificationType);  
             sourceLayer.InternalFeatures.Clear();  
             sourceLayer.InternalFeatures.Add(new Feature(multipolygonShape));  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             Feature feature = GeometrySource.FirstOrDefault();  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(feature);  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

SnapGPSSample.cs

 using Android.Content;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class SnapGPSSample : BaseSample  
     {  
         private InMemoryFeatureLayer inProcessLayer;  
         private InMemoryFeatureLayer resultLayer;  
 
         public SnapGPSSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             resultLayer.InternalFeatures.Clear();  
             if (resultLayer.InternalFeatures.Count == 0)  
             {  
                 inProcessLayer.IsVisible = false;  
 
                 Feature multilineFeature = inProcessLayer.InternalFeatures[0];  
                 MultilineShape multilineShape = (MultilineShape)multilineFeature.GetShape();  
                 Feature[] allFeatures = { inProcessLayer.InternalFeatures[1] };  
                 double tolerance = 100;  
 
                 Collection<Feature> matchFeatures = new Collection<Feature>();  
                 foreach (var item in allFeatures)  
                 {  
                     double tempDistance = multilineShape.GetShortestLineTo(item, GeographyUnit.Meter).GetLength(GeographyUnit.Meter, DistanceUnit.Feet);  
                     if (tempDistance < tolerance)  
                     {  
                         matchFeatures.Add(item);  
                     }  
                 }  
 
                 resultLayer.InternalFeatures.Add(multilineFeature);  
                 foreach (var feature in matchFeatures)  
                 {  
                     Collection<Vertex> vertices = new Collection<Vertex>();  
                     PointShape resultShape = multilineShape.GetClosestPointTo(feature, GeographyUnit.Meter);  
                     MultilineShape tempMultilineShape = feature.GetShape() as MultilineShape;  
                     if (tempMultilineShape != null)  
                     {  
                         double offsetX = resultShape.X - tempMultilineShape.Lines[0].Vertices[0].X;  
                         double offsetY = resultShape.Y - tempMultilineShape.Lines[0].Vertices[0].Y;  
                         vertices.Add(new Vertex(resultShape));  
 
                         double x = offsetX + tempMultilineShape.Lines[0].Vertices[1].X;  
                         double y = offsetY + tempMultilineShape.Lines[0].Vertices[1].Y;  
                         vertices.Add(new Vertex(x, y));  
                     }  
 
                     resultLayer.InternalFeatures.Add(new Feature(new MultilineShape(new[] { new LineShape(vertices) })));  
                 }  
 
                 foreach (var feature in allFeatures)  
                 {  
                     if (!matchFeatures.Contains(feature))  
                     {  
                         resultLayer.InternalFeatures.Add(feature);  
                     }  
                 }  
 
                 CollectVertices(resultLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);  
             }  
 
             layerOverlay.Refresh();  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             inProcessLayer = new InMemoryFeatureLayer();  
             resultLayer = new InMemoryFeatureLayer();  
 
             inProcessLayer.Open();  
             inProcessLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));  
 
             resultLayer.Open();  
             resultLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));  
 
             InitializeStyle();  
 
             foreach (var feature in GeometrySource)  
             {  
                 inProcessLayer.InternalFeatures.Add(feature);  
             }  
 
             CollectVertices(inProcessLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", inProcessLayer);  
             layerOverlay.Layers.Add("PointLayer", resultLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
 
         private static void CollectVertices(IEnumerable<Feature> features, InMemoryFeatureLayer featureLayer)  
         {  
             lock (features)  
             {  
                 foreach (var multilineShape in features.Select(f => f.GetShape()).OfType<MultilineShape>())  
                 {  
                     foreach (var vertex in multilineShape.Lines.SelectMany(l => l.Vertices))  
                     {  
                         EllipseShape ellipseShape = new EllipseShape(new PointShape(vertex), 30);  
                         featureLayer.InternalFeatures.Add(new Feature(ellipseShape));  
                     }  
                 }  
             }  
         }  
 
         private void InitializeStyle()  
         {  
             GeoColor semiTransparentOrange = GeoColor.FromArgb(140, 255, 155, 13);  
 
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 3, false);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Name", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             resultLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle;  
             resultLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 4, false);  
             resultLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
         }  
     }  
 }  
 

SplitSample.cs

 using Android.Content;  
 
 namespace GeometricFunctions  
 {  
     public class SplitSample : BaseSample  
     {  
         public SplitSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         {  
         }  
 
         protected override void InitalizeMap()  
         {  
         }  
     }  
 }  
 

UnionSample.cs

 using System.Collections.Generic;  
 using System.Linq;  
 using Android.Content;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public class UnionSample : BaseSample  
     {  
         public UnionSample(Context context, SliderView sliderView)  
             : base(context, sliderView)  
         { }  
 
         protected override void Execute()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
 
             if (sourceLayer.InternalFeatures.Count > 1)  
             {  
                 IEnumerable<AreaBaseShape> areaBaseShapes = sourceLayer.InternalFeatures.Select(f => f.GetShape()).OfType<AreaBaseShape>();  
 
                 AreaBaseShape unionedAreaBaseShape = AreaBaseShape.Union(areaBaseShapes);  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(unionedAreaBaseShape));  
 
                 layerOverlay.Refresh();  
             }  
         }  
 
         protected override void InitalizeMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
 
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.SimpleColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             foreach (Feature feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
 
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
     }  
 }  
 

BaseSample.cs

 using Android.App;  
 using Android.Content;  
 using Android.Graphics;  
 using Android.Util;  
 using Android.Views;  
 using Android.Widget;  
 using System;  
 using System.Collections.ObjectModel;  
 using ThinkGeo.MapSuite.AndroidEdition;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace GeometricFunctions  
 {  
     public abstract class BaseSample  
     {  
         protected static readonly GeoColor BrushColor = GeoColor.FromArgb(100, 0, 147, 221);  
 
         private MapView mapView;  
         private View sampleView;  
         private TextView titleTextView;  
         private SliderView sliderView;  
         private Button executeButton;  
         private Collection<Feature> geometrySource;  
 
         protected BaseSample(Context context, SliderView sliderView)  
         {  
             this.sliderView = sliderView;  
             this.sampleView = View.Inflate(context, Resource.Layout.SampleBaseLayout, null);  
             this.executeButton = sampleView.FindViewById<Button>(Resource.Id.ExecuteButton);  
             this.titleTextView = sampleView.FindViewById<TextView>(Resource.Id.TitleTextView);  
 
             ImageButton sampleListButton = sampleView.FindViewById<ImageButton>(Resource.Id.SampleListButton);  
             sampleListButton.Click += SampleListButtonClick;  
             executeButton.Click += ExecuteButtonClick;  
         }  
 
         public string TitleText  
         {  
             get { return titleTextView.Text; }  
             set { titleTextView.Text = value; }  
         }  
 
         public SliderView SliderView  
         {  
             get { return sliderView; }  
         }  
 
         public Collection<Feature> GeometrySource  
         {  
             get { return geometrySource ?? (geometrySource = new Collection<Feature>()); }  
         }  
 
         protected MapView MapView  
         {  
             get { return mapView ?? (mapView = new MapView(Application.Context)); }  
         }  
 
         public virtual View GetSampleView()  
         {  
             try  
             {  
                 FrameLayout mapContainerView = sampleView.FindViewById<FrameLayout>(Resource.Id.MapContainerView);  
 
                 mapContainerView.RemoveAllViews();  
                 mapView = new MapView(Application.Context);  
                 InitalizeBaseMap();  
                 InitalizeMap();  
 
                 mapContainerView.AddView(mapView);  
             }  
             catch (Exception ex)  
             {  
                 Log.Debug("Sample Changed", ex.Message);  
             }  
             return sampleView;  
         }  
 
         public void DisposeMap()  
         {  
             if (mapView != null && mapView.Parent != null)  
             {  
                 FrameLayout mapContainerView = sampleView.FindViewById<FrameLayout>(Resource.Id.MapContainerView);  
                 mapContainerView.RemoveAllViews();  
 
                 mapView.Dispose();  
                 mapView = null;  
                 GC.Collect();  
                 GC.WaitForPendingFinalizers();  
             }  
         }  
 
         protected abstract void InitalizeMap();  
 
         protected virtual void Execute()  
         { }  
 
         protected virtual RectangleShape GetBoundingBox()  
         {  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(100);  
             return mapExtent;  
         }  
 
         private void InitalizeBaseMap()  
         {  
             if (!MapView.Overlays.Contains("WMK"))  
             {  
                 MapView.SetBackgroundColor(Color.Argb(255, 244, 242, 238));  
                 WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();  
                 worldOverlay.TileType = TileType.MultiTile;  
                 worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
                 string baseFolder = Android.OS.Environment.ExternalStorageDirectory.AbsolutePath;  
                 string cachePathFilename = System.IO.Path.Combine(baseFolder, "MapSuiteTileCaches/SampleCaches.db");  
                 worldOverlay.TileCache = new SqliteBitmapTileCache(cachePathFilename, "SphericalMercator");  
                 MapView.Overlays.Insert(0, "WMK", worldOverlay);  
             }  
         }  
 
         private void SampleListButtonClick(object sender, EventArgs e)  
         {  
             sliderView.SetSlided(!sliderView.IsSlided());  
         }  
 
         private void ExecuteButtonClick(object sender, EventArgs e)  
         {  
             Execute();  
         }  
     }  
 }  
 

ActivityListItemAdapter.cs

 using Android.App;  
 using Android.Graphics;  
 using Android.Views;  
 using Android.Widget;  
 using System;  
 using System.Collections.Generic;  
 
 namespace GeometricFunctions  
 {  
     public class ActivityListItemAdapter : ArrayAdapter<Tuple<string, int>>  
     {  
         private Activity context;  
         private float ratio;  
 
         public ActivityListItemAdapter(Activity context, IList<Tuple<string, int>> objects)  
             : base(context, Android.Resource.Id.Text1, objects)  
         {  
             this.context = context;  
         }  
 
         public override View GetView(int position, View convertView, ViewGroup parent)  
         {  
             ratio = context.Resources.DisplayMetrics.Density;  
 
             LinearLayout layout = (LinearLayout)context.LayoutInflater.Inflate(Android.Resource.Layout.ActivityListItem, null);  
             var item = GetItem(position);  
 
             TextView textView = layout.FindViewById<TextView>(Android.Resource.Id.Text1);  
             textView.Text = item.Item1;  
             textView.SetTextColor(Color.Black);  
             textView.SetTextSize(Android.Util.ComplexUnitType.Px, 14 * ratio);  
             ((LinearLayout.LayoutParams)(textView.LayoutParameters)).Gravity = GravityFlags.CenterVertical;  
 
             ImageView imageView = layout.FindViewById<ImageView>(Android.Resource.Id.Icon);  
             imageView.SetImageResource(item.Item2);  
             imageView.LayoutParameters.Width = (int)(30 * ratio);  
             imageView.LayoutParameters.Height = (int)(30 * ratio);  
             ((LinearLayout.LayoutParams)imageView.LayoutParameters).SetMargins(0, (int)(2 * ratio), 0, (int)(2 * ratio));  
 
             return layout;  
         }  
     }  
 }  
 

SampleHelper.cs

 using System.IO;  
 
 namespace GeometricFunctions  
 {  
     internal class SampleHelper  
     {  
         public readonly static string AssetsDataDictionary = @"AppData";  
         public readonly static string SampleDataDictionary = @"mnt/sdcard/MapSuiteSampleData/GeometricFunctions";  
 
         public static string GetDataPath(string fileName)  
         {  
             return Path.Combine(SampleDataDictionary, AssetsDataDictionary, fileName);  
         }  
     }  
 }  
 

SliderView.cs

 using Android.Content;  
 using Android.Util;  
 using Android.Views;  
 using Android.Widget;  
 using System;  
 
 namespace GeometricFunctions  
 {  
     public class SliderView : ViewGroup  
     {  
         private static readonly int VELOCITY_X_SPEED = 800;  
 
         private float x;  
         private Context context;  
         private Scroller scroller;  
         private bool dispatched;  
         private bool slided;  
         private int leftViewWidth;  
         private int startScrollLeftOffset;  
         private VelocityTracker mVelocityTracker;  
 
         public SliderView(Context context, IAttributeSet attrs)  
             : base(context, attrs)  
         {  
             this.context = context;  
             this.leftViewWidth = 200;  
             this.scroller = new Scroller(context);  
         }  
 
         public int LeftViewWidth  
         {  
             get { return leftViewWidth; }  
             set { leftViewWidth = value; }  
         }  
 
         public View LeftView  
         {  
             get { return this.GetChildAt(0); }  
         }  
 
         public ViewGroup MainView  
         {  
             get { return this.GetChildAt(1) as ViewGroup; }  
         }  
 
         protected override void OnLayout(bool arg0, int arg1, int arg2, int arg3, int arg4)  
         {  
             int childCount = this.ChildCount;  
             for (int i = 0; i < childCount; ++i)  
             {  
                 View view = this.GetChildAt(i);  
                 if (view.Visibility != ViewStates.Gone)  
                 {  
                     view.Layout(0, 0, view.MeasuredWidth, view.MeasuredHeight);  
                 }  
             }  
         }  
 
         public override bool OnInterceptTouchEvent(MotionEvent ev)  
         {  
             return true;  
         }  
 
         public override bool OnTouchEvent(MotionEvent e)  
         {  
             if (mVelocityTracker == null)  
             {  
                 mVelocityTracker = VelocityTracker.Obtain();  
             }  
             mVelocityTracker.AddMovement(e);  
             MotionEventActions action = e.Action;  
             if (action == MotionEventActions.Down)  
             {  
                 x = e.GetX();  
 
                 if (IsSlided())  
                 {  
                     dispatched = DispatchTouchEventToView(GetChildAt(0), e);  
                 }  
                 else  
                 {  
                     dispatched = DispatchTouchEventToView(GetChildAt(1), e);  
                 }  
             }  
             else if (action == MotionEventActions.Move)  
             {  
                 if (dispatched)  
                 {  
                     if (IsSlided())  
                     {  
                         DispatchTouchEventToView(GetChildAt(0), e);  
                     }  
                     else  
                     {  
                         DispatchTouchEventToView(GetChildAt(1), e);  
                     }  
                 }  
                 else  
                 {  
                     float dx = e.GetX() - x;  
                     View view = this.GetChildAt(1);  
                     int left = (int)(view.Left + dx);  
                     if (left >= 0)  
                     {  
                         view.Layout(left, view.Top, view.Width + left,  
                                 view.Top + view.Height);  
                     }  
                 }  
                 x = e.GetX();  
             }  
             else if (action == MotionEventActions.Cancel  
                   || action == MotionEventActions.Up)  
             {  
                 if (dispatched)  
                 {  
                     if (IsSlided())  
                     {  
                         DispatchTouchEventToView(GetChildAt(0), e);  
                     }  
                     else  
                     {  
                         DispatchTouchEventToView(GetChildAt(1), e);  
                     }  
                 }  
                 else  
                 {  
                     mVelocityTracker.ComputeCurrentVelocity(1000);  
                     int velocityX = (int)mVelocityTracker.GetXVelocity(0);  
                     if (velocityX > VELOCITY_X_SPEED)  
                     {  
                         SetSlided(true);  
                     }  
                     else if (velocityX < -VELOCITY_X_SPEED)  
                     {  
                         SetSlided(false);  
                     }  
                     else  
                     {  
                         View view = GetChildAt(1);  
                         if (view.Left >= view.Width / 2)  
                         {  
                             SetSlided(true);  
                         }  
                         else  
                         {  
                             SetSlided(false);  
                         }  
                     }  
                     if (mVelocityTracker != null)  
                     {  
                         try  
                         {  
                             mVelocityTracker.Recycle();  
                         }  
                         catch  
                         { }  
                     }  
                 }  
             }  
             else if (!IsSlided())  
             {  
                 DispatchTouchEventToView(GetChildAt(1), e);  
             }  
             return true;  
         }  
 
         public bool IsSlided()  
         {  
             return slided;  
         }  
 
         public void SetSlided(bool slided)  
         {  
             View view = GetChildAt(1);  
             startScrollLeftOffset = view.Left;  
             if (slided)  
             {  
                 scroller.StartScroll(0, Top, (int)(leftViewWidth * context.Resources.DisplayMetrics.Density) - startScrollLeftOffset, 0);  
             }  
             else  
             {  
                 scroller.StartScroll(0, Top, -startScrollLeftOffset, 0);  
             }  
             this.slided = slided;  
             PostInvalidate();  
         }  
 
 
         public override void ComputeScroll()  
         {  
             if (scroller.ComputeScrollOffset())  
             {  
                 View view = GetChildAt(1);  
                 int left = startScrollLeftOffset + scroller.CurrX;  
                 view.Layout(left, view.Top, left + view.Width, view.Height);  
                 PostInvalidate();  
             }  
         }  
 
         protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)  
         {  
             base.OnMeasure(widthMeasureSpec, heightMeasureSpec);  
             for (int i = 0; i < ChildCount; ++i)  
             {  
                 GetChildAt(i).Measure(widthMeasureSpec, heightMeasureSpec);  
             }  
         }  
 
         public bool DispatchTouchEventToView(View view, MotionEvent ev)  
         {  
             try  
             {  
                 return view.DispatchTouchEvent(ev);  
             }  
             catch (Exception e)  
             {  
                 // some machines will throw exception  
 
             }  
             return false;  
         }  
     }  
 }  
 
source_code_androideditionsample_geometricfunctions.zip.txt · Last modified: 2015/09/14 02:20 by admin

Page Tools