using System;  
 using System.Threading.Tasks;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public class App : Application  
     {  
         private MasterDetailPage mainPage;  
 
         public App()  
         {  
             InitializeStyles();  
 
             mainPage = new MasterDetailPage();  
             mainPage.IsGestureEnabled = false;  
             mainPage.Title = "Labeling Style";  
 
             SampleListPage sampleListPage = new SampleListPage();  
             sampleListPage.SelectedSampleChanged += SampleListViewModel_SelectedSampleChanged;  
 
             sampleListPage.SelectedSample = sampleListPage.Samples[0];  
             mainPage.Master = sampleListPage;  
             MainPage = mainPage;  
         }  
 
         private void SampleListViewModel_SelectedSampleChanged(object sender, EventArgs e)  
         {  
             ContentPage contentPage = null;  
             SampleListPage sampleListViewModel = (SampleListPage)sender;  
             BaseSampleView newSample = (BaseSampleView)Activator.CreateInstance(sampleListViewModel.SelectedSample.SampleType);  
 
             if (mainPage.Detail == null)  
             {  
                 mainPage.Detail = new NavigationPage(new ContentPage { Title = "Labeling Style" });  
             }  
 
             NavigationPage navigationPage = (NavigationPage)mainPage.Detail;  
             contentPage = (ContentPage)navigationPage.CurrentPage;  
 
             BaseSampleView oldSample = contentPage.Content as BaseSampleView;  
             if (oldSample != null && !oldSample.Equals(newSample))  
             {  
                 Task.Run(() => Device.BeginInvokeOnMainThread(oldSample.Dispose));  
             }  
 
             contentPage.Content = newSample;  
             contentPage.ToolbarItems.Clear();  
             if (newSample.SettingsToolbarItem != null) contentPage.ToolbarItems.Add(newSample.SettingsToolbarItem);  
 
             mainPage.IsPresented = false;  
         }  
 
         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.Center });  
             Application.Current.Resources.Add("SettingsListLabelStyle", settingsListLabelStyle);  
 
             Style sampleApplyButtonStyle = new Style(typeof(Button));  
             sampleApplyButtonStyle.Setters.Add(new Setter { Property = Button.BackgroundColorProperty, Value = Color.FromHex("#e0e0e0") });  
             sampleApplyButtonStyle.Setters.Add(new Setter { Property = Button.TextColorProperty, Value = Color.FromHex("#000000") });  
             sampleApplyButtonStyle.Setters.Add(new Setter { Property = Button.TextProperty, Value = "Apply" });  
             Application.Current.Resources.Add("SampleApplyButtonStyle", sampleApplyButtonStyle);  
 
             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 sampleApplyButtonContainerStyle = new Style(typeof(Grid));  
             sampleApplyButtonContainerStyle.Setters.Add(new Setter { Property = Grid.PaddingProperty, Value = new Thickness(5, 20, 5, 5) });  
             Application.Current.Resources.Add("SampleApplyButtonContainerStyle", sampleApplyButtonContainerStyle);  
 
             Style settingsTitleContainerStyle = new Style(typeof(Grid));  
             settingsTitleContainerStyle.Setters.Add(new Setter { Property = Grid.PaddingProperty, Value = new Thickness(5) });  
             Application.Current.Resources.Add("SettingsListLineStyle", settingsTitleContainerStyle);  
         }  
     }  
 }  
 
 

 using System;  
 
 namespace LabelingStyle  
 {  
     public class ApplyingSettingsEventArgs : EventArgs  
     {  
         private StyleSettings settings;  
 
         public ApplyingSettingsEventArgs(StyleSettings settings)  
         {  
             this.settings = settings;  
         }  
 
         public StyleSettings Settings  
         {  
             get { return settings; }  
         }  
     }  
 }  
 
 

 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("LabelingStyle")]  
 [assembly: AssemblyDescription("")]  
 [assembly:|AssemblyConfiguration("")]  
 [assembly: AssemblyCompany("")]  
 [assembly:|AssemblyProduct("LabelingStyle")]  
 [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")]  
 
 

 using System;  
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class SampleListPage : ContentPage  
     {  
         private SampleItem selectedSample;  
         private ObservableCollection<SampleItem> samples;  
         private Command openHelpUriCommand;  
 
         public event EventHandler SelectedSampleChanged;  
 
         public SampleListPage()  
         {  
             InitializeComponent();  
 
             samples = new ObservableCollection<SampleItem>();  
             samples.Add(new SampleItem("Labeling Points", "LabelingPointsIcon", typeof(LabelingPointsSample)));  
             samples.Add(new SampleItem("Labeling Lines", "LabelingLinesIcon", typeof(LabelingLinesSample)));  
             samples.Add(new SampleItem("Labeling Polygons", "LabelingPolygonsIcon", typeof(LabelingPolygonsSample)));  
             samples.Add(new SampleItem("Label Styling", "LabelStylingIcon", typeof(LabelStylingSample)));  
             samples.Add(new SampleItem("Custom Labeling", "CustomLabelingIcon", typeof(CustomLabelingSample)));  
 
             BindingContext = this;  
         }  
 
         public SampleItem SelectedSample  
         {  
             get  
             {  
                 return selectedSample;  
             }  
             set  
             {  
                 if (selectedSample != value)  
                 {  
                     selectedSample = value;  
                     OnPropertyChanged("SelectedSample");  
                     OnSelectedSampleChanged();  
                 }  
             }  
         }  
 
         public ObservableCollection<SampleItem> Samples  
         {  
             get { return samples; }  
         }  
 
         public Command OpenHelpUriCommand  
         {  
             get  
             {  
                 openHelpUriCommand = openHelpUriCommand ?? new Command(() => Device.OpenUri(new Uri("http://www.thinkgeo.com")));  
                 return openHelpUriCommand;  
             }  
         }  
 
         protected virtual void OnSelectedSampleChanged()  
         {  
             EventHandler handler = SelectedSampleChanged;  
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public abstract class BaseSampleSettingsPage : ContentPage  
     {  
         public event EventHandler<ApplyingSettingsEventArgs> ApplyingSettings;  
 
         private StyleSettings settings;  
 
         public BaseSampleSettingsPage(StyleSettings settings)  
         {  
             this.settings = settings;  
         }  
 
         public StyleSettings Settings  
         {  
             get { return settings; }  
         }  
 
         protected virtual void OnApplyingSettings()  
         {  
             EventHandler<ApplyingSettingsEventArgs> handler = ApplyingSettings;  
 
             if (handler != null)  
             {  
                 handler(this, new ApplyingSettingsEventArgs(settings));  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public abstract class BaseSampleView : ContentView, IDisposable  
     {  
         private MapView mapView;  
         private StyleSettings settings;  
         private ToolbarItem settingsToolbarItem;  
         private BaseSampleSettingsPage settingsPage;  
 
         public BaseSampleView()  
         {  
             mapView = new MapView();  
             mapView.MapUnit = GeographyUnit.DecimalDegree;  
             mapView.CurrentExtent = new RectangleShape(-30, 10, 10, -10);  
             mapView.BackgroundColor = Color.FromRgba(244, 242, 238, 255);  
 
             Grid mainGrid = new Grid();  
             mainGrid.Children.Add(mapView);  
             Content = mainGrid;  
 
             InitalizeMap();  
             if (SettingsPage != null)  
             {  
                 SettingsToolbarItem = new ToolbarItem("Settings", "settings40", async () =>  
                 {  
                     await Navigation.PushAsync(SettingsPage, true);  
                 });  
                 SettingsPage.ApplyingSettings += SettingsPageApplyingSettings;  
             }  
         }  
 
         private void SettingsPageApplyingSettings(object sender, ApplyingSettingsEventArgs e)  
         {  
             AppliedSettings(e);  
         }  
 
         public StyleSettings Settings  
         {  
             get { return settings; }  
             set { settings = value; }  
         }  
 
         public BaseSampleSettingsPage SettingsPage  
         {  
             get { return settingsPage; }  
             set { settingsPage = value; }  
         }  
 
         public MapView MapView  
         {  
             get { return mapView; }  
         }  
 
         public ToolbarItem SettingsToolbarItem  
         {  
             get { return settingsToolbarItem; }  
             set { settingsToolbarItem = value; }  
         }  
 
         protected abstract void InitalizeMap();  
 
         protected abstract void AppliedSettings(ApplyingSettingsEventArgs e);  
 
         ~BaseSampleView()  
         {  
             Dispose(false);  
         }  
 
         public void Dispose()  
         {  
             Dispose(true);  
             GC.SuppressFinalize(this);  
         }  
 
         protected virtual void Dispose(bool disposing)  
         {  
             if (disposing)  
             {  
                 mapView.Dispose();  
                 SettingsPage.ApplyingSettings -= SettingsPageApplyingSettings;  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public class SampleItem  
     {  
         private string name;  
         private ImageSource icon;  
         private Type sampleType;  
 
         public SampleItem(string name, string iconPathFilename, Type sampleType)  
         {  
             this.name = name;  
             this.icon = new FileImageSource { File = iconPathFilename };  
             this.sampleType = sampleType;  
         }  
 
         public string Name  
         {  
             get { return name; }  
             set { name = value; }  
         }  
 
         public ImageSource Icon  
         {  
             get { return icon; }  
             set { icon = value; }  
         }  
 
         public Type SampleType  
         {  
             get { return sampleType; }  
             set { sampleType = value; }  
         }  
     }  
 }  
 
 

 namespace LabelingStyle  
 {  
     public abstract class StyleSettings  
     {  
         public StyleSettings()  
         {  
         }  
 
         public string Title { get; set; }  
 
         /// <summary>  
         /// Parses to double.  
         /// </summary>  
         /// <param name="source">The source.</param>  
         /// <param name="defaultValue">The default value.</param>  
         /// <returns>System.Double.</returns>  
         public double ParseToDouble(string source, double defaultValue)  
         {  
             double temp;  
             double result = defaultValue;  
             if (double.TryParse(source, out temp))  
             {  
                 result = temp;  
             }  
 
             return result;  
         }  
 
         /// <summary>  
         /// Parses to int.  
         /// </summary>  
         /// <param name="source">The source.</param>  
         /// <param name="defaultValue">The default value.</param>  
         /// <returns>System.Int32.</returns>  
         public int ParseToInt(string source, int defaultValue)  
         {  
             int temp;  
             int result = defaultValue;  
             if (int.TryParse(source, out temp))  
             {  
                 result = temp;  
             }  
 
             return result;  
         }  
 
         /// <summary>  
         /// Parses to float.  
         /// </summary>  
         /// <param name="source">The source.</param>  
         /// <param name="defaultValue">The default value.</param>  
         /// <returns>System.Single.</returns>  
         public float ParseToFloat(string source, float defaultValue)  
         {  
             float temp;  
             float result = defaultValue;  
             if (float.TryParse(source, out temp))  
             {  
                 result = temp;  
             }  
 
             return result;  
         }  
     }  
 }  
 

 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace LabelingStyle  
 {  
     public class CustomLabelingSample : BaseSampleView  
     {  
         protected override void InitalizeMap()  
         {  
             Settings = new CustomLabelingStyleSettings();  
             SettingsPage = new CustomLabelingSettingsPage((CustomLabelingStyleSettings)Settings);  
 
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = new RectangleShape(-10777472.620674, 3909177.1327916, -10776518.8812938, 3907779.90459956);  
 
             WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();  
             worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             MapView.Overlays.Add("WMK", worldOverlay);  
 
             ShapeFileFeatureLayer customLabelingStyleLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("POIs.shp"));  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.FromHtml("#99cc33")), new GeoPen(GeoColor.FromHtml("#666666"), 1), 7);  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle = new CustomLabelStyle("Name", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.StandardColors.White, 1);  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.Mask = new AreaStyle();  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.XOffsetInPixel = 10;  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.YOffsetInPixel = 10;  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.PointPlacement = PointPlacement.Center;  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;  
             customLabelingStyleLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             customLabelingStyleLayer.DrawingMarginPercentage = 100;  
 
             LayerOverlay customLabelingOverlay = new LayerOverlay();  
             customLabelingOverlay.Layers.Add("customLabeling", customLabelingStyleLayer);  
             MapView.Overlays.Add("CustomLabeling", customLabelingOverlay);  
         }  
 
         protected override void AppliedSettings(ApplyingSettingsEventArgs e)  
         {  
             LayerOverlay layerOverlay=(LayerOverlay)MapView.Overlays["CustomLabeling"];  
             CustomLabelingStyleSettings settings = (CustomLabelingStyleSettings)e.Settings;  
 
             FeatureLayer featureLayer = (FeatureLayer)layerOverlay.Layers["customLabeling"];  
             CustomLabelStyle customLabelStyle = featureLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle as CustomLabelStyle;  
             if (customLabelStyle != null)  
             {  
                 customLabelStyle.MinFontSize = settings.MinFontSize;  
                 customLabelStyle.MaxFontSize = settings.MaxFontSize;  
             }  
 
             layerOverlay.Refresh();  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class CustomLabelingSettingsPage : BaseSampleSettingsPage  
     {  
         private CustomLabelingStyleSettings settings;  
 
         public CustomLabelingSettingsPage(CustomLabelingStyleSettings settings)  
             : base(settings)  
         {  
             InitializeComponent();  
 
             this.settings = settings;  
             this.Title = settings.Title;  
 
             ToolbarItems.Add(new ToolbarItem("Exit", "quit", async () =>  
             {  
                 await Navigation.PopAsync(true);  
             }));  
 
             minFontSizeEntry.Text = settings.MinFontSize.ToString();  
             maxFontSizeEntry.Text = settings.MaxFontSize.ToString();  
 
             applyButton.Clicked += ApplyButtonClicked;  
         }  
 
         private async void ApplyButtonClicked(object sender, EventArgs e)  
         {  
             settings.MinFontSize = settings.ParseToInt(minFontSizeEntry.Text, settings.MinFontSize);  
             settings.MaxFontSize = settings.ParseToInt(maxFontSizeEntry.Text, settings.MaxFontSize);  
 
             await Navigation.PopAsync(true);  
             OnApplyingSettings();  
         }  
     }  
 }  
 
 

 namespace LabelingStyle  
 {  
     public class CustomLabelingStyleSettings : StyleSettings  
     {  
         public CustomLabelingStyleSettings()  
         {  
             Title = "Custom Labeling Edit Settings";  
 
             MinFontSize = 8;  
             MaxFontSize = 60;  
         }  
 
         public int MinFontSize { get; set; }  
         public int MaxFontSize { get; set; }  
     }  
 }  
 
 

 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace LabelingStyle  
 {  
     public class CustomLabelStyle : TextStyle  
     {  
         private float minFontSize;  
         private float maxFontSize;  
 
         public CustomLabelStyle(string textColumnName, GeoFont textFont, GeoSolidBrush textSolidBrush)  
             : base(textColumnName, textFont, textSolidBrush)  
         {  
             this.minFontSize = 8;  
             this.MaxFontSize = 60;  
         }  
 
         public float MinFontSize  
         {  
             get { return minFontSize; }  
             set { minFontSize = value; }  
         }  
 
         public float MaxFontSize  
         {  
             get { return maxFontSize; }  
             set { maxFontSize = value; }  
         }  
 
         protected override void DrawCore(IEnumerable<Feature> features, GeoCanvas canvas, Collection<SimpleCandidate> labelsInThisLayer, Collection<SimpleCandidate> labelsInAllLayers)  
         {  
             TextStyle clonedStyle = new TextStyle(this.TextColumnName, this.Font, this.TextSolidBrush);  
             clonedStyle.HaloPen = this.HaloPen;  
             clonedStyle.Mask = this.Mask;  
             clonedStyle.GridSize = this.GridSize;  
             clonedStyle.OverlappingRule = this.OverlappingRule;  
             clonedStyle.DuplicateRule = this.DuplicateRule;  
 
             float fontSize = Convert.ToInt32(50000 / canvas.CurrentScale);  
 
             if (fontSize < minFontSize)  
             {  
                 fontSize = minFontSize;  
             }  
             else if (fontSize > maxFontSize)  
             {  
                 fontSize = maxFontSize;  
             }  
 
             clonedStyle.Font = new GeoFont(clonedStyle.Font.FontName, fontSize, clonedStyle.Font.Style);  
             clonedStyle.Draw(features, canvas, labelsInThisLayer, labelsInAllLayers);  
         }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace LabelingStyle  
 {  
     public class LabelingLinesSample : BaseSampleView  
     {  
         protected override void InitalizeMap()  
         {  
             Settings = new LabelingLinesStyleSettings();  
             SettingsPage = new LabelingLinesSettingsPage((LabelingLinesStyleSettings)Settings);  
 
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = new RectangleShape(-10777472.620674, 3909177.1327916, -10776518.8812938, 3907779.90459956);  
 
             ShapeFileFeatureLayer streetLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("Street.shp"));  
             streetLayer.ZoomLevelSet.ZoomLevel10.CustomStyles.Add(GetRoadStyle());  
             streetLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             streetLayer.DrawingMarginPercentage = 50;  
 
             LayerOverlay labelingLinesOverlay = new LayerOverlay();  
             labelingLinesOverlay.Layers.Add("street", streetLayer);  
             MapView.Overlays.Add("LabelingLine", labelingLinesOverlay);  
         }  
 
         protected override void AppliedSettings(ApplyingSettingsEventArgs e)  
         {  
             LabelingLinesStyleSettings settings = (LabelingLinesStyleSettings)e.Settings;  
             LayerOverlay labelingStyleOverlay = MapView.Overlays["LabelingLine"] as LayerOverlay;  
 
             if (labelingStyleOverlay != null)  
             {  
                 FeatureLayer featureLayer = (FeatureLayer)labelingStyleOverlay.Layers["street"];  
                 ClassBreakStyle classBreakStyle = featureLayer.ZoomLevelSet.ZoomLevel10.CustomStyles[0] as ClassBreakStyle;  
                 if (classBreakStyle != null)  
                 {  
                     foreach (var classBreak in classBreakStyle.ClassBreaks)  
                     {  
                         classBreak.DefaultTextStyle.SplineType = settings.SplineType;  
                         classBreak.DefaultTextStyle.TextLineSegmentRatio = settings.LineSegmentRatio;  
                     }  
                 }  
 
                 labelingStyleOverlay.Refresh();  
             }  
         }  
 
         private ClassBreakStyle GetRoadStyle()  
         {  
             ClassBreakStyle roadStyle = new ClassBreakStyle("Type");  
 
             ClassBreak pwyBreak = new ClassBreak();  
             pwyBreak.Value = 1;  
             pwyBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#544c63"), 12f), new GeoPen(GeoColor.FromHtml("#9e98b0"), 8f));  
 
             pwyBreak.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 12, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             pwyBreak.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 2);  
             pwyBreak.DefaultTextStyle.Mask = new AreaStyle();  
             pwyBreak.DefaultTextStyle.BestPlacement = true;  
             roadStyle.ClassBreaks.Add(pwyBreak);  
 
             ClassBreak mainRoad = new ClassBreak();  
             mainRoad.Value = 4;  
             mainRoad.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#544c63"), 10f), new GeoPen(GeoColor.FromHtml("#e9cab0"), 7f));  
             mainRoad.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 10, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             mainRoad.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 1);  
             mainRoad.DefaultTextStyle.Mask = new AreaStyle();  
             mainRoad.DefaultTextStyle.BestPlacement = true;  
             roadStyle.ClassBreaks.Add(mainRoad);  
 
             ClassBreak localRoadBreak = new ClassBreak();  
             localRoadBreak.Value = 5;  
             localRoadBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#bba7a2"), 6f), new GeoPen(GeoColor.FromHtml("#ffffff"), 4f));  
             localRoadBreak.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 8, DrawingFontStyles.Regular), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             localRoadBreak.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 2);  
             localRoadBreak.DefaultTextStyle.Mask = new AreaStyle();  
             localRoadBreak.DefaultTextStyle.BestPlacement = true;  
             roadStyle.ClassBreaks.Add(localRoadBreak);  
 
             return roadStyle;  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class LabelingLinesSettingsPage : BaseSampleSettingsPage  
     {  
         private LabelingLinesStyleSettings settings;  
 
         public LabelingLinesSettingsPage(LabelingLinesStyleSettings settings)  
             : base(settings)  
         {  
             InitializeComponent();  
             this.Title = settings.Title;  
             this.settings = settings;  
 
             ToolbarItems.Add(new ToolbarItem("Exit", "quit", async () =>  
             {  
                 await Navigation.PopAsync(true);  
             }));  
 
             splineTypePicker.Items.Add("Default");  
             splineTypePicker.Items.Add("None");  
             splineTypePicker.Items.Add("StandardSplining");  
             splineTypePicker.Items.Add("ForceSplining ");  
 
             splineTypePicker.SelectedIndex = (int)settings.SplineType;  
             lineSegmentRatioEntry.Text = settings.LineSegmentRatio.ToString();  
 
             applyButton.Clicked += ApplyButtonClicked;  
         }  
 
         private async void ApplyButtonClicked(object sender, EventArgs e)  
         {  
             settings.SplineType = (SplineType)splineTypePicker.SelectedIndex;  
             settings.LineSegmentRatio = settings.ParseToDouble(lineSegmentRatioEntry.Text, settings.LineSegmentRatio);  
 
             await Navigation.PopAsync(true);  
             OnApplyingSettings();  
         }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 
 namespace LabelingStyle  
 {  
     public class LabelingLinesStyleSettings : StyleSettings  
     {  
         public LabelingLinesStyleSettings()  
         {  
             Title = "Labeling Lines Edit Settings";  
             SplineType = SplineType.Default;  
             LineSegmentRatio = 0.9;  
         }  
 
         public SplineType SplineType { get; set; }  
         public double LineSegmentRatio { get; set; }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace LabelingStyle  
 {  
     public class LabelingPointsSample : BaseSampleView  
     {  
         protected override void InitalizeMap()  
         {  
             Settings = new LabelingPointsStyleSettings();  
             SettingsPage = new LabelingPointsSettingsPage((LabelingPointsStyleSettings)Settings);  
 
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = new RectangleShape(-10777472.620674, 3909177.1327916, -10776518.8812938, 3907779.90459956);  
 
             WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();  
             worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             MapView.Overlays.Add("WMK", worldOverlay);  
 
             ShapeFileFeatureLayer poiLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("POIs.shp"));  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.FromHtml("#99cc33")), new GeoPen(GeoColor.FromHtml("#666666"), 1), 7);  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle = new TextStyle("Name", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.StandardColors.White, 2);  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.Mask = new AreaStyle();  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.XOffsetInPixel = 0;  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.YOffsetInPixel = 8;  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.PointPlacement = PointPlacement.UpperCenter;  
             poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;  
             poiLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             poiLayer.DrawingMarginPercentage = 100;  
 
             LayerOverlay labelingPointsOverlay = new LayerOverlay();  
             labelingPointsOverlay.Layers.Add("poi", poiLayer);  
             MapView.Overlays.Add("LabelingPoints", labelingPointsOverlay);  
         }  
 
         protected override void AppliedSettings(ApplyingSettingsEventArgs e)  
         {  
             LayerOverlay labelingPointsOverlay = MapView.Overlays["LabelingPoints"] as LayerOverlay;  
             if (labelingPointsOverlay != null)  
             {  
                 LabelingPointsStyleSettings settings = (LabelingPointsStyleSettings)e.Settings;  
                 FeatureLayer poiLayer = (FeatureLayer)labelingPointsOverlay.Layers["poi"];  
 
                 poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.PointPlacement = settings.Placement;  
                 poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.XOffsetInPixel = settings.XOffset;  
                 poiLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.YOffsetInPixel = settings.YOffset;  
 
                 labelingPointsOverlay.Refresh();  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class LabelingPointsSettingsPage : BaseSampleSettingsPage  
     {  
         private LabelingPointsStyleSettings settings;  
 
         public LabelingPointsSettingsPage(LabelingPointsStyleSettings settings)  
             : base(settings)  
         {  
             InitializeComponent();  
             this.settings = settings;  
             this.Title = settings.Title;  
 
             ToolbarItems.Add(new ToolbarItem("Exit", "quit", async () =>  
             {  
                 await Navigation.PopAsync(true);  
             }));  
 
             pointPlacementPicker.Items.Add("UpperLeft");  
             pointPlacementPicker.Items.Add("UpperCenter");  
             pointPlacementPicker.Items.Add("UpperRight");  
             pointPlacementPicker.Items.Add("CenterRight");  
             pointPlacementPicker.Items.Add("Center");  
             pointPlacementPicker.Items.Add("CenterLeft");  
             pointPlacementPicker.Items.Add("LowerLeft");  
             pointPlacementPicker.Items.Add("LowerCenter");  
             pointPlacementPicker.Items.Add("LowerRight");  
 
             pointPlacementPicker.SelectedIndex = (int)settings.Placement;  
             xOffsetEntry.Text = settings.XOffset.ToString();  
             yOffsetEntry.Text = settings.YOffset.ToString();  
 
             applyButton.Clicked += ApplyButtonClicked;  
         }  
 
         private async void ApplyButtonClicked(object sender, EventArgs e)  
         {  
             settings.Placement = (PointPlacement)pointPlacementPicker.SelectedIndex;  
             settings.XOffset = settings.ParseToFloat(xOffsetEntry.Text, settings.XOffset);  
             settings.YOffset = settings.ParseToFloat(yOffsetEntry.Text, settings.YOffset);  
 
             await Navigation.PopAsync(true);  
             OnApplyingSettings();  
         }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 
 namespace LabelingStyle  
 {  
     public class LabelingPointsStyleSettings : StyleSettings  
     {  
         public LabelingPointsStyleSettings()  
         {  
             Title = "Labeling Points Edit Settings";  
             Placement = PointPlacement.UpperCenter;  
             XOffset = 0;  
             YOffset = 8;  
         }  
 
         public PointPlacement Placement { get; set; }  
         public float XOffset { get; set; }  
         public float YOffset { get; set; }  
     }  
 }  
 
 

 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace LabelingStyle  
 {  
     public class LabelingPolygonsSample : BaseSampleView  
     {  
         protected override void InitalizeMap()  
         {  
             Settings = new LabelingPolygonsStyleSettings();  
             SettingsPage = new LabelingPolygonsSettingsPage((LabelingPolygonsStyleSettings)Settings);  
 
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = new RectangleShape(-10777472.620674, 3909177.1327916, -10776518.8812938, 3907779.90459956);  
 
             ShapeFileFeatureLayer subdivisionsLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("Subdivisions.shp"));  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.White, GeoColor.FromHtml("#9C9C9C"), 1);  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle = new TextStyle("NAME_COMMO", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.StandardColors.White, 1);  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.Mask = new AreaStyle();  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.BestPlacement = true;  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.GridSize = 3000;  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.DuplicateRule = LabelDuplicateRule.NoDuplicateLabels;  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.SuppressPartialLabels = true;  
             subdivisionsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
 
             LayerOverlay labelingPolygonsOverlay = new LayerOverlay();  
             labelingPolygonsOverlay.Layers.Add("subdivision", subdivisionsLayer);  
             MapView.Overlays.Add("LabelingPolygons", labelingPolygonsOverlay);  
         }  
 
         protected override void AppliedSettings(ApplyingSettingsEventArgs e)  
         {  
             LayerOverlay labelingStyleOverlay = MapView.Overlays["LabelingPolygons"] as LayerOverlay;  
             if (labelingStyleOverlay != null)  
             {  
                 LabelingPolygonsStyleSettings settings = (LabelingPolygonsStyleSettings)e.Settings;  
                 FeatureLayer featureLayer = (FeatureLayer)labelingStyleOverlay.Layers["subdivision"];  
                 featureLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.FittingPolygonFactor = settings.FittingFactorsOnlyWithin ? 2 : 0;  
                 featureLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.LabelAllPolygonParts = settings.LabelAllPolygonParts;  
                 labelingStyleOverlay.Refresh();  
             }  
         }  
     }  
 }  
 
 

 using System;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class LabelingPolygonsSettingsPage : BaseSampleSettingsPage  
     {  
         private LabelingPolygonsStyleSettings settings;  
 
         public LabelingPolygonsSettingsPage(LabelingPolygonsStyleSettings settings)  
             : base(settings)  
         {  
             InitializeComponent();  
             this.settings = settings;  
             this.Title = settings.Title;  
 
             ToolbarItems.Add(new ToolbarItem("Exit", "quit", async () =>  
             {  
                 await Navigation.PopAsync(true);  
             }));  
 
             labelAllSwitch.IsToggled = settings.LabelAllPolygonParts;  
             fittingFactorsSwitch.IsToggled = settings.FittingFactorsOnlyWithin;  
 
             applyButton.Clicked += ApplyButtonClicked;  
         }  
 
         private async void ApplyButtonClicked(object sender, EventArgs e)  
         {  
             settings.LabelAllPolygonParts = labelAllSwitch.IsToggled;  
             settings.FittingFactorsOnlyWithin = fittingFactorsSwitch.IsToggled;  
 
             await Navigation.PopAsync(true);  
             OnApplyingSettings();  
         }  
     }  
 }  
 
 

 namespace LabelingStyle  
 {  
     public class LabelingPolygonsStyleSettings : StyleSettings  
     {  
         public LabelingPolygonsStyleSettings()  
         {  
             Title = "Labeling Polygons Edit Settings";  
             FittingFactorsOnlyWithin = true;  
             LabelAllPolygonParts = false;  
         }  
 
         public bool FittingFactorsOnlyWithin { get; set; }  
         public bool LabelAllPolygonParts { get; set; }  
     }  
 }  
 
 

 using System.Collections.Generic;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 
 namespace LabelingStyle  
 {  
     public class LabelStylingSample : BaseSampleView  
     {  
         protected override void InitalizeMap()  
         {  
             Settings = new LabelStylingStyleSettings();  
             SettingsPage = new LabelStylingSettingsPage((LabelStylingStyleSettings)Settings);  
 
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = new RectangleShape(-10777472.620674, 3909177.1327916, -10776518.8812938, 3907779.90459956);  
 
             ShapeFileFeatureLayer parcelLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("Parcels.shp"));  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultAreaStyle = new AreaStyle(new GeoPen(GeoColor.FromHtml("#666666"), 2), new GeoSolidBrush(GeoColor.SimpleColors.White), PenBrushDrawingOrder.PenFirst);  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle = new TextStyle("X_REF", new GeoFont("Arail", 6, DrawingFontStyles.Regular), new GeoSolidBrush(GeoColor.FromHtml("#7b7b78")));  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.DuplicateRule = LabelDuplicateRule.NoDuplicateLabels;  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.GridSize = 1000;  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 1);  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.Mask = new AreaStyle();  
             parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;  
             parcelLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             parcelLayer.DrawingMarginPercentage = 50;  
 
             ShapeFileFeatureLayer streetLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("Street.shp"));  
             streetLayer.ZoomLevelSet.ZoomLevel10.CustomStyles.Add(GetRoadStyle());  
             streetLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             streetLayer.DrawingMarginPercentage = 50;  
 
             ShapeFileFeatureLayer restaurantsLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath("POIs.shp"));  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.FromHtml("#99cc33")), new GeoPen(GeoColor.FromHtml("#666666"), 1), 7);  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle = new TextStyle("Name", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 1);  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.XOffsetInPixel = 10;  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.Mask = new AreaStyle(new GeoPen(GeoColor.FromHtml("#999999"), 1), new GeoSolidBrush(new GeoColor(100, GeoColor.FromHtml("#cccc99"))), PenBrushDrawingOrder.PenFirst);  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restaurantsLayer.DrawingMarginPercentage = 50;  
 
             LayerOverlay labelingStyleOverlay = new LayerOverlay();  
             labelingStyleOverlay.Layers.Add(parcelLayer);  
             labelingStyleOverlay.Layers.Add(streetLayer);  
             labelingStyleOverlay.Layers.Add(restaurantsLayer);  
             MapView.Overlays.Add("LabelingStyle", labelingStyleOverlay);  
         }  
 
         protected override void AppliedSettings(ApplyingSettingsEventArgs e)  
         {  
             LayerOverlay labelingStyleOverlay = MapView.Overlays["LabelingStyle"] as LayerOverlay;  
             if (labelingStyleOverlay != null)  
             {  
                 LabelStylingStyleSettings settings = (LabelStylingStyleSettings)e.Settings;  
 
                 bool useHalopen = settings.ApplyOutlineColor;  
                 bool useMask = settings.ApplyBackgroundMask;  
                 bool allowOverlapping = settings.LabelsOverlappingEachOther;  
                 LabelDuplicateRule labelDuplicateRule = settings.DuplicateRule;  
                 double drawingMarginPercentage = settings.DrawingMarginPercentage;  
                 int gridSizeValue = settings.GetGridSizeValue();  
 
                 ShapeFileFeatureLayer featureLayer = (ShapeFileFeatureLayer)labelingStyleOverlay.Layers["poi"];  
                 List<TextStyle> textStyles = new List<TextStyle>();  
                 if (featureLayer.ZoomLevelSet.ZoomLevel10.CustomStyles.Count > 0)  
                 {  
                     ClassBreakStyle classBreakStyle = featureLayer.ZoomLevelSet.ZoomLevel10.CustomStyles[0] as ClassBreakStyle;  
                     textStyles.AddRange(classBreakStyle.ClassBreaks.Select(c => c.DefaultTextStyle));  
                 }  
                 else  
                 {  
                     textStyles.Add(featureLayer.ZoomLevelSet.ZoomLevel10.DefaultTextStyle);  
                 }  
 
                 foreach (var textStyle in textStyles)  
                 {  
                     int r = textStyle.HaloPen.Color.RedComponent;  
                     int g = textStyle.HaloPen.Color.GreenComponent;  
                     int b = textStyle.HaloPen.Color.BlueComponent;  
 
                     if (useHalopen)  
                     {  
                         textStyle.HaloPen = new GeoPen(GeoColor.FromArgb(255, r, g, b), textStyle.HaloPen.Width);  
                     }  
                     else  
                     {  
                         textStyle.HaloPen = new GeoPen(GeoColor.FromArgb(0, r, g, b), textStyle.HaloPen.Width);  
                     }  
 
                     textStyle.Mask.IsActive = useMask;  
                     textStyle.GridSize = gridSizeValue;  
                     textStyle.DuplicateRule = labelDuplicateRule;  
                     textStyle.OverlappingRule = allowOverlapping ? LabelOverlappingRule.AllowOverlapping : LabelOverlappingRule.NoOverlapping;  
                     featureLayer.DrawingMarginPercentage = drawingMarginPercentage;  
                 }  
                 labelingStyleOverlay.Refresh();  
             }  
         }  
 
         private ClassBreakStyle GetRoadStyle()  
         {  
             ClassBreakStyle roadStyle = new ClassBreakStyle("Type");  
             ClassBreak pwyBreak = new ClassBreak();  
             pwyBreak.Value = 1;  
             pwyBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#544c63"), 12f), new GeoPen(GeoColor.FromHtml("#9e98b0"), 8f));  
             pwyBreak.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 12, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             pwyBreak.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 2);  
             pwyBreak.DefaultTextStyle.Mask = new AreaStyle();  
             roadStyle.ClassBreaks.Add(pwyBreak);  
 
             ClassBreak mainRoad = new ClassBreak();  
             mainRoad.Value = 4;  
             mainRoad.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#544c63"), 10f), new GeoPen(GeoColor.FromHtml("#e9cab0"), 7f));  
             mainRoad.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 10, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             mainRoad.DefaultTextStyle.HaloPen = new GeoPen(GeoColor.SimpleColors.White, 1);  
             mainRoad.DefaultTextStyle.Mask = new AreaStyle();  
             roadStyle.ClassBreaks.Add(mainRoad);  
 
             ClassBreak localRoadBreak = new ClassBreak();  
             localRoadBreak.Value = 5;  
             localRoadBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#bba7a2"), 8f), new GeoPen(GeoColor.FromHtml("#ffffff"), 6f));  
             localRoadBreak.DefaultTextStyle = new TextStyle("ROAD_NAME", new GeoFont("Arial", 8, DrawingFontStyles.Regular), new GeoSolidBrush(GeoColor.SimpleColors.Black));  
             localRoadBreak.DefaultTextStyle.Mask = new AreaStyle();  
             roadStyle.ClassBreaks.Add(localRoadBreak);  
             return roadStyle;  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public partial class LabelStylingSettingsPage : BaseSampleSettingsPage  
     {  
         private LabelStylingStyleSettings settings;  
 
         public LabelStylingSettingsPage(LabelStylingStyleSettings settings)  
             : base(settings)  
         {  
             InitializeComponent();  
             this.Title = settings.Title;  
             this.settings = settings;  
 
             ToolbarItems.Add(new ToolbarItem("Exit", "quit", async () =>  
             {  
                 await Navigation.PopAsync(true);  
             }));  
 
             outlineColorSwitch.IsToggled = settings.ApplyOutlineColor;  
             backgroundMaskSwitch.IsToggled = settings.ApplyBackgroundMask;  
             labelsOverlappingSwitch.IsToggled = settings.LabelsOverlappingEachOther;  
 
             gridSizePicker.Items.Add("Small");  
             gridSizePicker.Items.Add("Medium");  
             gridSizePicker.Items.Add("Large");  
 
             duplicateRulePicker.Items.Add("OneDuplicateLabelPerQuadrant");  
             duplicateRulePicker.Items.Add("NoDuplicateLabels");  
             duplicateRulePicker.Items.Add("UnlimitedDuplicateLabels");  
 
             drawingMarginsEntry.Text = settings.DrawingMarginPercentage.ToString();  
 
             gridSizePicker.SelectedIndex = (int)settings.GridSize;  
             duplicateRulePicker.SelectedIndex = (int)settings.DuplicateRule;  
 
             applyButton.Clicked += ApplyButtonClicked;  
         }  
 
         private async void ApplyButtonClicked(object sender, EventArgs e)  
         {  
             settings.ApplyOutlineColor = outlineColorSwitch.IsToggled;  
             settings.ApplyBackgroundMask = backgroundMaskSwitch.IsToggled;  
             settings.LabelsOverlappingEachOther = labelsOverlappingSwitch.IsToggled;  
 
             settings.GridSize = (LabelGridSize)gridSizePicker.SelectedIndex;  
             settings.DuplicateRule = (LabelDuplicateRule)duplicateRulePicker.SelectedIndex;  
             settings.DrawingMarginPercentage = settings.ParseToDouble(drawingMarginsEntry.Text, settings.DrawingMarginPercentage);  
 
             await Navigation.PopAsync(true);  
             OnApplyingSettings();  
         }  
     }  
 }  
 
 

 using System.Collections.Generic;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace LabelingStyle  
 {  
     public class LabelStylingStyleSettings : StyleSettings  
     {  
         private Dictionary<string, int> gridSizeDictionary;  
 
         public LabelStylingStyleSettings()  
         {  
             Title = "Label Styling Edit Settings";  
             ApplyOutlineColor = true;  
             ApplyBackgroundMask = true;  
             LabelsOverlappingEachOther = false;  
             GridSize = LabelGridSize.Large;  
             DuplicateRule = LabelDuplicateRule.NoDuplicateLabels;  
             DrawingMarginPercentage = 50;  
 
             gridSizeDictionary = new Dictionary<string, int>();  
             gridSizeDictionary["Small"] = 100;  
             gridSizeDictionary["Medium"] = 500;  
             gridSizeDictionary["Large"] = 1000;  
         }  
 
         public bool ApplyOutlineColor { get; set; }  
         public bool ApplyBackgroundMask { get; set; }  
         public bool LabelsOverlappingEachOther { get; set; }  
         public LabelGridSize GridSize { get; set; }  
         public LabelDuplicateRule DuplicateRule { get; set; }  
         public double DrawingMarginPercentage { get; set; }  
 
         public int GetGridSizeValue()  
         {  
             return gridSizeDictionary[GridSize.ToString()];  
         }  
     }  
 
     public enum LabelGridSize  
     {  
         Small = 0,  
         Medium = 1,  
         Large = 2  
     }  
 }  
 

 using System.IO;  
 using Xamarin.Forms;  
 
 namespace LabelingStyle  
 {  
     public class SampleHelper  
     {  
         public static readonly string AssetsDataDictionary = Device.OnPlatform("SampleData", "SampleData", string.Empty);  
         public static readonly string SampleDataDictionary = Device.OnPlatform(string.Empty, @"mnt/sdcard/MapSuiteSampleData/LabelingStyle", string.Empty);  
 
         public static string GetDataPath(string fileName)  
         {  
             string result = string.IsNullOrEmpty(SampleDataDictionary) ? Path.Combine(AssetsDataDictionary, fileName)  
                 : Path.Combine(SampleDataDictionary, AssetsDataDictionary, fileName);  
             return result;  
         }  
     }  
 }