====== Source Code WebAPIEditionSample Basic Styling.zip ======


====Global.asax.cs====
<code csharp>
using System.Web.Http;
using System.Web.Mvc;

namespace BasicStyling
{
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }
    }
}
</code>
====WebApiConfig.cs====
<code csharp>
using System.Web.Http;

namespace BasicStyling
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            //Enable RouteAttribute
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            //Enable RouteAttribute, if delete this line, will throw other exceptions
            config.EnsureInitialized();
        }
    }
}

</code>
====BasicStylingController.cs====
<code csharp>
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.WebApiEdition;

namespace BasicStyling.Controllers
{
    [RoutePrefix("BasicStyling")]
    public class BasicStylingController : ApiController
    {
        static BasicStylingController()
        { }

        [Route("{styleId}/{z}/{x}/{y}/{accessId}")]
        [HttpGet]
        public HttpResponseMessage GetDynamicLayerTile(string styleId, int z, int x, int y, string accessId)
        {
            LayerOverlay layerOverlay = GetStyleOverlay(styleId, accessId);

            return DrawTileImage(layerOverlay, z, x, y);
        }

        private LayerOverlay GetStyleOverlay(string styleId, string accessId)
        {
            LayerOverlay layerOverlay = new LayerOverlay();
            switch (styleId)
            {
                case "PredefinedStyles":
                    foreach (var layer in LayerBuilder.GetPredefinedStyleLayers())
                    {
                        layerOverlay.Layers.Add(layer);
                    }
                    break;
                case "AreaStyle":
                    layerOverlay.Layers.Add(LayerBuilder.GetAreaStyleLayer(styleId, accessId));
                    break;
                case "LineStyle":
                    layerOverlay.Layers.Add(LayerBuilder.GetLineStyleLayer(styleId, accessId));
                    break;
                case "ImagePointStyle":
                    layerOverlay.Layers.Add(LayerBuilder.GeImagePointStyleLayer());
                    break;
                case "SymbolPoint":
                    layerOverlay.Layers.Add(LayerBuilder.GetSymbolPointLayer(styleId, accessId));
                    break;
                case "CharacterPoint":
                    layerOverlay.Layers.Add(LayerBuilder.GetCharacterPointLayer());
                    break;
                case "StyleByZoomLevel":
                    foreach (var layer in LayerBuilder.GetMultipleStyleLayers())
                    {
                        layerOverlay.Layers.Add(layer);
                    }
                    break;
                case "CompoundStyle":
                    layerOverlay.Layers.Add(LayerBuilder.GetCompoundStyleLayer());
                    break;
                default:
                    break;
            }
            return layerOverlay;
        }

        [Route("GetStyle/{styleId}/{accessId}")]
        public Dictionary<string, object> GetStyle(string styleId, string accessId)
        {
            Dictionary<string, object> styles = new Dictionary<string, object>();
            switch (styleId)
            {
                case "AreaStyle":
                    styles = LayerBuilder.GetAreaLayerStyle(styleId, accessId);
                    break;
                case "LineStyle":
                    styles = LayerBuilder.GetLineLayerStyle(styleId, accessId);
                    break;
                case "SymbolPoint":
                    styles = LayerBuilder.GetSymbolPointLayerStyle(styleId, accessId);
                    break;
            }
            return styles;
        }

        [Route("UpdateStyle/{styleId}/{accessId}")]
        public bool UpdateStyle(string styleId, string accessId, [FromBody] string postData)
        {
            Dictionary<string, string> styles = JsonConvert.DeserializeObject<Dictionary<string, string>>(postData);

            LayerBuilder.UpdateLayerStyle(styleId, accessId, styles);

            return true;
        }

        private HttpResponseMessage DrawTileImage(LayerOverlay layerOverlay, int z, int x, int y)
        {

            using (Bitmap bitmap = new Bitmap(256, 256))
            {
                GdiPlusGeoCanvas geoCanvas = new GdiPlusGeoCanvas();
                RectangleShape boundingBox = WebApiExtentHelper.GetBoundingBoxForXyz(x, y, z, GeographyUnit.Meter);
                geoCanvas.BeginDrawing(bitmap, boundingBox, GeographyUnit.Meter);
                layerOverlay.Draw(geoCanvas);
                geoCanvas.EndDrawing();

                MemoryStream ms = new MemoryStream();
                bitmap.Save(ms, ImageFormat.Png);

                HttpResponseMessage msg = new HttpResponseMessage(HttpStatusCode.OK);
                msg.Content = new ByteArrayContent(ms.ToArray());
                msg.Content.Headers.ContentType = new MediaTypeHeaderValue("image/png");

                return msg;
            }
        }
    }
}

</code>
====LayerBuilder.cs====
<code csharp>
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using ThinkGeo.MapSuite.Core;

namespace BasicStyling.Controllers
{
    public static class LayerBuilder
    {
        private static readonly string baseDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data");

        internal static Dictionary<string, object> GetAreaLayerStyle(string styleId, string accessId)
        {
            FeatureLayer featureLayer = (FeatureLayer)GetAreaStyleLayer(styleId, accessId);

            Dictionary<string, object> styles = new Dictionary<string, object>();
            GeoColor fillSolidBrushColor = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color;
            styles["FillSolidBrushColor"] = fillSolidBrushColor.HtmlColor;
            styles["FillSolidBrushAalpha"] = fillSolidBrushColor.AlphaComponent;
            GeoColor outlinePenColor = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color;
            styles["OutlinePenColor"] = outlinePenColor.HtmlColor;
            styles["OutlinePenAalpha"] = outlinePenColor.AlphaComponent;
            styles["OutlinePenWidth"] = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width;
            return styles;
        }

        internal static Dictionary<string, object> GetLineLayerStyle(string styleId, string accessId)
        {
            FeatureLayer featureLayer = (FeatureLayer)GetLineStyleLayer(styleId, accessId);

            Dictionary<string, object> styles = new Dictionary<string, object>();
            GeoPen centerPen = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.CenterPen;
            styles["CenterPenColor"] = centerPen.Color.HtmlColor;
            styles["CenterPenAlpha"] = centerPen.Color.AlphaComponent;
            styles["CenterPenWidth"] = centerPen.Width;

            GeoPen innerPen = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen;
            styles["InnerPenColor"] = innerPen.Color.HtmlColor;
            styles["InnerPenAlpha"] = innerPen.Color.AlphaComponent;
            styles["InnerPenWidth"] = innerPen.Width;

            GeoPen outerPen = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen;
            styles["OuterPenColor"] = outerPen.Color.HtmlColor;
            styles["OuterPenAlpha"] = outerPen.Color.AlphaComponent;
            styles["OuterPenWidth"] = outerPen.Width;
            return styles;
        }

        internal static Dictionary<string, object> GetSymbolPointLayerStyle(string styleId, string accessId)
        {
            FeatureLayer featureLayer = (FeatureLayer)GetSymbolPointLayer(styleId, accessId);

            Dictionary<string, object> styles = new Dictionary<string, object>();
            PointStyle targetPointStyle = featureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle;
            styles["SymbolPointType"] = targetPointStyle.SymbolType;
            styles["SymbolPointSize"] = targetPointStyle.SymbolSize;
            styles["symbolPointRotationAngle"] = targetPointStyle.RotationAngle;

            GeoPen symbolPen = targetPointStyle.SymbolPen;
            styles["SymbolPenColor"] = symbolPen.Color.HtmlColor;
            styles["SymbolPointPenAlpha"] = symbolPen.Color.AlphaComponent;
            styles["SymbolPointPenWidth"] = symbolPen.Width;

            GeoColor symbolSolidBrushColor = targetPointStyle.SymbolSolidBrush.Color;
            styles["SymbolSolidBrushColor"] = symbolSolidBrushColor.HtmlColor;
            styles["SymbolSolidBrushAlpha"] = symbolSolidBrushColor.AlphaComponent;
            return styles;
        }

        internal static void UpdateLayerStyle(string styleId, string accessId, Dictionary<string, string> styles)
        {
            string styleFile = string.Format("{0}_{1}.json", accessId, styleId);
            string styleFilePath = Path.Combine(baseDirectory, "Temp", styleFile);

            using (StreamWriter streamWriter = new StreamWriter(styleFilePath, false))
            {
                streamWriter.WriteLine(JsonConvert.SerializeObject(styles));
            }
        }

        internal static Collection<Layer> GetPredefinedStyleLayers()
        {
            Collection<Layer> layers = new Collection<Layer>();
            BackgroundLayer backgroundLayer = new BackgroundLayer(WorldMapKitAreaStyles.Water().FillSolidBrush);
            layers.Add(backgroundLayer);

            ShapeFileFeatureLayer countriesLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "Countries.shp"));
            countriesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.BaseLand();
            countriesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColors.Gray);
            countriesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layers.Add(countriesLayer);

            ShapeFileFeatureLayer lakeLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "lake.shp"));
            lakeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.Water();
            lakeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layers.Add(lakeLayer);

            ShapeFileFeatureLayer usStatesLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "USStates.shp"));
            usStatesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.BaseLand();
            usStatesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layers.Add(usStatesLayer);

            ShapeFileFeatureLayer highwayNetworkShapeLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "USHighwayNetwork.shp"));
            highwayNetworkShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = WorldMapKitLineStyles.Highway(1);
            highwayNetworkShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layers.Add(highwayNetworkShapeLayer);

            ShapeFileFeatureLayer majorCitiesLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "USMajorCities.shp"));
            majorCitiesLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = WorldMapKitTextStyles.Poi("AREANAME", 7, 7);
            majorCitiesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layers.Add(majorCitiesLayer);

            return layers;
        }

        internal static Layer GetAreaStyleLayer(string styleId, string accessId)
        {
            ShapeFileFeatureLayer areaShapeLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoArea.shp"));
            AreaStyle areaStyle = new AreaStyle();
            areaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(200, GeoColor.SimpleColors.LightOrange));
            areaStyle.OutlinePen = new GeoPen(new GeoSolidBrush(new GeoColor(200, GeoColor.SimpleColors.LightBlue)), 2);
            areaShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = areaStyle;
            areaShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Dictionary<string, string> savedStyle = GetSavedStyleByAccessId(styleId, accessId);
            if (savedStyle != null) UpdateAreaStyle(areaShapeLayer, savedStyle);

            return areaShapeLayer;
        }

        internal static Layer GetLineStyleLayer(string styleId, string accessId)
        {
            ShapeFileFeatureLayer lineShapeLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "MajorRoadsInFrisco.shp"));
            LineStyle lineStyle = new LineStyle();
            lineStyle.CenterPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.PastelGreen), 2);
            lineStyle.InnerPen = new GeoPen(new GeoColor(255, GeoColors.Black), 5);
            lineStyle.OuterPen = new GeoPen(new GeoColor(255, GeoColors.YellowGreen), 10);
            lineShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = lineStyle;
            lineShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Dictionary<string, string> savedStyle = GetSavedStyleByAccessId(styleId, accessId);
            if (savedStyle != null) UpdateLineStyle(lineShapeLayer, savedStyle);

            return lineShapeLayer;
        }

        internal static Layer GeImagePointStyleLayer()
        {
            ShapeFileFeatureLayer ImagePointStyleLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "HighSchoolInFrisco.shp"));
            PointStyle pointOfHighSchoolStyle = new PointStyle();
            pointOfHighSchoolStyle.Image = new GeoImage(Path.Combine(baseDirectory, "school.png"));
            pointOfHighSchoolStyle.PointType = PointType.Bitmap;
            pointOfHighSchoolStyle.RotationAngle = 0;

            ImagePointStyleLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = pointOfHighSchoolStyle;
            ImagePointStyleLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            return ImagePointStyleLayer;
        }

        internal static Layer GetSymbolPointLayer(string styleId, string accessId)
        {
            ShapeFileFeatureLayer symblePointLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoLocation.shp"));
            var colors = GeoColor.GetColorsInHueFamily(GeoColor.SimpleColors.Red, 10);

            symblePointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Triangle, colors[1], GeoColor.SimpleColors.Blue, 1, 20);
            symblePointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Dictionary<string, string> savedStyle = GetSavedStyleByAccessId(styleId, accessId);
            if (savedStyle != null) UpdateSymbolPointStyle(symblePointLayer, savedStyle);

            return symblePointLayer;
        }

        internal static Layer GetCharacterPointLayer()
        {
            ShapeFileFeatureLayer characterPointLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "HospitalInFrisco.shp"));

            PointStyle hospitalPointStyle = new PointStyle();
            hospitalPointStyle.PointType = PointType.Character;
            hospitalPointStyle.RotationAngle = 0;
            hospitalPointStyle.CharacterIndex = 72;
            GeoFont geoFont = new GeoFont("Arial", 20);
            geoFont.IsBold = true;
            hospitalPointStyle.CharacterFont = geoFont;
            hospitalPointStyle.CharacterSolidBrush = new GeoSolidBrush(GeoColors.Blue);

            characterPointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = hospitalPointStyle;
            characterPointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            return characterPointLayer;
        }

        internal static Collection<Layer> GetMultipleStyleLayers()
        {
            Collection<Layer> layers = new Collection<Layer>();

            ShapeFileFeatureLayer ZoomLevelAreaShapeLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoArea.shp"));

            AreaStyle ZoomLevelAreaStyleFrom01To16 = new AreaStyle();
            ZoomLevelAreaStyleFrom01To16.FillSolidBrush = new GeoSolidBrush(new GeoColor(100, GeoColor.SimpleColors.BrightOrange));
            ZoomLevelAreaStyleFrom01To16.OutlinePen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.Black));
            ZoomLevelAreaShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = ZoomLevelAreaStyleFrom01To16;
            ZoomLevelAreaShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level16;

            AreaStyle ZoomLevelAreaStyle17 = new AreaStyle();
            ZoomLevelAreaStyle17.FillSolidBrush = new GeoSolidBrush(new GeoColor(100, GeoColor.SimpleColors.Blue));
            ZoomLevelAreaStyle17.OutlinePen = new GeoPen(new GeoColor(255, 0, 0, 0));
            ZoomLevelAreaShapeLayer.ZoomLevelSet.ZoomLevel17.DefaultAreaStyle = ZoomLevelAreaStyle17;

            AreaStyle ZoomLevelAreaStyle18 = new AreaStyle();
            ZoomLevelAreaStyle18.FillSolidBrush = new GeoSolidBrush(new GeoColor(100, GeoColor.SimpleColors.Red));
            ZoomLevelAreaStyle18.OutlinePen = new GeoPen(new GeoColor(255, 0, 0, 0));
            ZoomLevelAreaShapeLayer.ZoomLevelSet.ZoomLevel18.DefaultAreaStyle = ZoomLevelAreaStyle18;

            AreaStyle ZoomLevelAreaStyle19 = new AreaStyle();
            ZoomLevelAreaStyle19.FillSolidBrush = new GeoSolidBrush(new GeoColor(100, GeoColor.SimpleColors.Green));
            ZoomLevelAreaStyle19.OutlinePen = new GeoPen(new GeoColor(255, 0, 0, 0));
            ZoomLevelAreaShapeLayer.ZoomLevelSet.ZoomLevel19.DefaultAreaStyle = ZoomLevelAreaStyle19;

            layers.Add(ZoomLevelAreaShapeLayer);

            ShapeFileFeatureLayer zoomLevelLineLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoLine.shp"));

            LineStyle zoomLevelLineStyleFrom01To16 = new LineStyle();
            zoomLevelLineStyleFrom01To16.CenterPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.DarkOrange), 5);
            zoomLevelLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = zoomLevelLineStyleFrom01To16;
            zoomLevelLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level16;

            LineStyle zoomLevelLineStyle17 = new LineStyle();
            zoomLevelLineStyle17.CenterPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.DarkBlue), 5);
            zoomLevelLineLayer.ZoomLevelSet.ZoomLevel17.DefaultLineStyle = zoomLevelLineStyle17;

            LineStyle zoomLevelLineStyle18 = new LineStyle();
            zoomLevelLineStyle18.CenterPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.LightOrange), 5);
            zoomLevelLineLayer.ZoomLevelSet.ZoomLevel18.DefaultLineStyle = zoomLevelLineStyle18;

            LineStyle zoomLevelLineStyle19 = new LineStyle();
            zoomLevelLineStyle19.CenterPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.LightGreen), 5);
            zoomLevelLineLayer.ZoomLevelSet.ZoomLevel19.DefaultLineStyle = zoomLevelLineStyle19;
            layers.Add(zoomLevelLineLayer);

            ShapeFileFeatureLayer ZoomLevelPointLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoLocation.shp"));
            ZoomLevelPointLayer.Transparency = 200f;

            PointStyle pointStyleForZoomLevelFrom01To16 = new PointStyle();
            pointStyleForZoomLevelFrom01To16.Image = new GeoImage(Path.Combine(baseDirectory, "ThinkGeoLogo.png"));
            pointStyleForZoomLevelFrom01To16.PointType = PointType.Bitmap;
            pointStyleForZoomLevelFrom01To16.RotationAngle = 0;
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = pointStyleForZoomLevelFrom01To16;
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level16;

            PointStyle pointStyleForZoomLevel17 = new PointStyle();
            pointStyleForZoomLevel17.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.SimpleColors.DarkBlue), 8);
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel17.DefaultPointStyle = pointStyleForZoomLevel17;

            TextStyle textStyleForZoomLevel18 = new TextStyle("name", (new GeoFont("Arial", 12)), new GeoSolidBrush(GeoColor.SimpleColors.LightRed));
            textStyleForZoomLevel18.HaloPen = new GeoPen(GeoColor.StandardColors.FloralWhite, 5);
            textStyleForZoomLevel18.SplineType = SplineType.ForceSplining;
            PointStyle pointStyleForZoomLevel18 = new PointStyle();
            pointStyleForZoomLevel18.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.SimpleColors.LightRed), 8);
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel18.CustomStyles.Add(textStyleForZoomLevel18);
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel18.CustomStyles.Add(pointStyleForZoomLevel18);

            PointStyle pointStyleForZoomLevel19 = new PointStyle();
            pointStyleForZoomLevel19.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.SimpleColors.DarkGreen), 8);
            ZoomLevelPointLayer.ZoomLevelSet.ZoomLevel19.DefaultPointStyle = pointStyleForZoomLevel19;

            layers.Add(ZoomLevelPointLayer);

            return layers;
        }

        internal static Layer GetCompoundStyleLayer()
        {
            ShapeFileFeatureLayer compoundStyleLayer = new ShapeFileFeatureLayer(Path.Combine(baseDirectory, "ThinkGeoLocation.shp"));

            PointStyle circleStyle = new PointStyle();
            circleStyle.PointType = PointType.Symbol;
            circleStyle.SymbolPen = new GeoPen(new GeoColor(255, GeoColor.SimpleColors.Red), 3);
            circleStyle.SymbolType = PointSymbolType.Circle;
            circleStyle.SymbolSize = 25;

            PointStyle starStyle = new PointStyle();
            starStyle.PointType = PointType.Symbol;
            starStyle.SymbolSolidBrush = new GeoSolidBrush(new GeoColor(255, GeoColor.SimpleColors.Blue));
            starStyle.SymbolType = PointSymbolType.Star;
            starStyle.SymbolSize = 20;
            starStyle.XOffsetInPixel = 1;
            starStyle.YOffsetInPixel = 3;

            compoundStyleLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(circleStyle);
            compoundStyleLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(starStyle);
            compoundStyleLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            return compoundStyleLayer;
        }

        private static Dictionary<string, string> GetSavedStyleByAccessId(string overlayId, string accessId)
        {
            string styleFile = string.Format("{0}_{1}.json", accessId, overlayId);
            string styleFilePath = Path.Combine(baseDirectory, "Temp", styleFile);

            if (File.Exists(styleFilePath))
            {
                string content = File.ReadAllText(styleFilePath);
                return JsonConvert.DeserializeObject<Dictionary<string, string>>(content);
            }

            return null;
        }

        private static void UpdateAreaStyle(FeatureLayer featureLayer, Dictionary<string, string> savedStyle)
        {
            string fillSolidBrushStr = savedStyle["fillSolidBrushColor"];
            int fillSolidBrushAlpha = int.Parse(savedStyle["fillSolidBrushAlpha"]);
            string outerPenStr = savedStyle["outerPenColor"];
            int outerPenAlpha = int.Parse(savedStyle["outerPenAlpha"]);
            int outerPenWidth = int.Parse(savedStyle["outerPenWidth"]);

            AreaStyle areaStyle = new AreaStyle();
            areaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(fillSolidBrushAlpha, GeoColor.FromHtml(fillSolidBrushStr)));
            areaStyle.OutlinePen = new GeoPen(new GeoColor(outerPenAlpha, GeoColor.FromHtml(outerPenStr)), outerPenWidth);
            featureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = areaStyle;
            featureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
        }

        private static void UpdateLineStyle(FeatureLayer featureLayer, Dictionary<string, string> savedStyle)
        {
            string centerPenColor = savedStyle["centerPenColor"];
            int centerPenColorAlpha = int.Parse(savedStyle["centerPenColorAlpha"]);
            int centerPenWidth = int.Parse(savedStyle["centerPenWidth"]);

            string outterPenColor = savedStyle["outterPenColor"];
            int outterPenColorAlpha = int.Parse(savedStyle["outterPenColorAlpha"]);
            int outterPenWidth = int.Parse(savedStyle["outterPenWidth"]);

            string innerPenColor = savedStyle["innerPenColor"];
            int innerPenColorAlpha = int.Parse(savedStyle["innerPenColorAlpha"]);
            int innerPenWidth = int.Parse(savedStyle["innerPenWidth"]);
            GeoPen centerPen = new GeoPen(new GeoColor(centerPenColorAlpha, GeoColor.FromHtml(centerPenColor)), centerPenWidth);
            GeoPen outterPen = new GeoPen(new GeoColor(outterPenColorAlpha, GeoColor.FromHtml(outterPenColor)), outterPenWidth);
            GeoPen innerPen = new GeoPen(new GeoColor(innerPenColorAlpha, GeoColor.FromHtml(innerPenColor)), innerPenWidth);

            LineStyle lineStyle = new LineStyle();
            lineStyle.CenterPen = centerPen;
            lineStyle.OuterPen = outterPen;
            lineStyle.InnerPen = innerPen;

            featureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = lineStyle;
            featureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
        }

        private static void UpdateSymbolPointStyle(FeatureLayer featureLayer, Dictionary<string, string> savedStyle)
        {
            string symbolPointType = savedStyle["symbolPointType"];
            int symbolPointSize = int.Parse(savedStyle["symbolPointSize"]);
            float symbolPointRotationAngle = float.Parse(savedStyle["symbolPointRotationAngle"]);

            string symbolPointPenColor = savedStyle["symbolPointPenColor"];
            int symbolPointPenAlpha = int.Parse(savedStyle["symbolPointPenAlpha"]);
            int symbolPointPenWidth = int.Parse(savedStyle["symbolPointPenWidth"]);

            string symbolPointSolidBrushColor = savedStyle["symbolPointSolidBrushColor"];
            int symbolPointSolidBrushAlpha = int.Parse(savedStyle["symbolPointSolidBrushAlpha"]);

            PointStyle thinkGeoLocationStyle = new PointStyle();
            thinkGeoLocationStyle.PointType = PointType.Symbol;
            thinkGeoLocationStyle.SymbolType = (PointSymbolType)Enum.Parse(typeof(PointSymbolType), symbolPointType, true);
            thinkGeoLocationStyle.SymbolSize = symbolPointSize;
            thinkGeoLocationStyle.RotationAngle = symbolPointRotationAngle;
            thinkGeoLocationStyle.SymbolPen = new GeoPen(new GeoColor(symbolPointPenAlpha, GeoColor.FromHtml(symbolPointPenColor)), symbolPointPenWidth);
            thinkGeoLocationStyle.SymbolSolidBrush = new GeoSolidBrush(new GeoColor(symbolPointSolidBrushAlpha, GeoColor.FromHtml(symbolPointSolidBrushColor)));

            featureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = thinkGeoLocationStyle;
            featureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
        }
    }
}
</code>
====AssemblyInfo.cs====
<code csharp>
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BasicStyling")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BasicStyling")]
[assembly: AssemblyCopyright("Copyright ©  2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("ccb52e05-3e33-4575-a5e0-b82966ac1e0b")]

// 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 Revision and Build Numbers 
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

</code>
====Global.asax.cs====
<code csharp>
using System.Web.Http;
using System.Web.Mvc;

namespace BasicStyling
{
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801

    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }
    }
}
</code>
====WebApiConfig.cs====
<code csharp>
using System.Web.Http;

namespace BasicStyling
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            //Enable RouteAttribute
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            //Enable RouteAttribute, if delete this line, will throw other exceptions
            config.EnsureInitialized();
        }
    }
}

</code>
====AssemblyInfo.cs====
<code csharp>
using System.Reflection;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BasicStyling")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BasicStyling")]
[assembly: AssemblyCopyright("Copyright ©  2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("aa6124eb-8e23-48fc-9a48-60d654efa9a0")]

// 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 Revision and Build Numbers 
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

</code>