User Tools

Site Tools

Trace: • source_code_webapieditionsample_styles.zip

Sidebar

ThinkGeo Cloud

ThinkGeo UI Controls

ThinkGeo Open Source

Help and Support

External Resources

source_code_webapieditionsample_styles.zip

Table of Contents

Source Code WebAPIEditionSample Basic Styling.zip

Global.asax.cs

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);
        }
    }
}

WebApiConfig.cs

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();
        }
    }
}

BasicStylingController.cs

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;
            }
        }
    }
}

LayerBuilder.cs

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;
        }
    }
}

AssemblyInfo.cs

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")]

Global.asax.cs

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);
        }
    }
}

WebApiConfig.cs

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();
        }
    }
}

AssemblyInfo.cs

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")]
source_code_webapieditionsample_styles.zip.txt · Last modified: 2015/11/11 06:07 by tgwikiupdate

Page Tools