ThinkGeo Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Source Code WorldMapWmsService Project Templates Desktop CS.zip ======

====MapModel.cs====

<code csharp>   
 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Configuration;  
 using System.Drawing;  
 using System.Globalization;  
 using System.IO;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 using ThinkGeo.MapSuite.WorldMapWmsServiceClient.Properties;  
  
 namespace ThinkGeo.MapSuite.WorldMapWmsServiceClient  
 {  
     public class MapModel  
     {  
         private ShapeFileFeatureLayer currentQueryLayer;  
  
         private WinformsMap mapControl;  
  
         private ObservableCollection<ShapeFileFeatureLayer> poiLayers;  
  
         private BaseShape restrictionShape;  
  
         private PointShape selectedPoint;  
  
         public MapModel(WinformsMap winformsMap)  
         {  
             mapControl = winformsMap;  
             mapControl.MapUnit = GeographyUnit.Meter;  
             mapControl.AdornmentOverlay.ShowLogo = false;  
  
             AddBaseMapOverlays();  
             AddAdornmentLayers();  
  
             mapControl.CurrentExtent = new RectangleShape(-10782584.5066971, 3916291.54400321, -10769504.2529497, 3907774.56943023);  
             mapControl.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;  
             mapControl.Refresh();  
         }  
  
         public event EventHandler<PlottedPointMapModelEventArgs> PlottedPoint;  
  
         public ShapeFileFeatureLayer CurrentQueryLayer  
         {  
             get { return currentQueryLayer; }  
             set { currentQueryLayer = value; }  
         }  
  
         public ShapeFileFeatureLayer HotelsLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.HotelsLayerKey];  
             }  
         }  
  
         public WinformsMap MapControl  
         {  
             get { return mapControl; }  
         }  
  
         public GeographyUnit MapUnit  
         {  
             get { return mapControl.MapUnit; }  
         }  
  
         public ShapeFileFeatureLayer MedicalFacilitesLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.MedicalFacilitesLayerKey];  
             }  
         }  
  
         public ShapeFileFeatureLayer PublicFacilitesLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.PublicFacilitesLayerKey];  
             }  
         }  
  
         public ShapeFileFeatureLayer RestaurantsLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.RestaurantsLayerKey];  
             }  
         }  
  
  
         public ShapeFileFeatureLayer SchoolsLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.SchoolsLayerKey];  
             }  
         }  
  
         public PointShape SelectedPoint  
         {  
             get { return selectedPoint; }  
             set { selectedPoint = value; }  
         }  
  
         public InMemoryFeatureLayer ServiceAreaLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.CustomOverlayKey];  
                 return (InMemoryFeatureLayer)overlay.Layers[Resources.ServiceAreaLayerKey];  
             }  
         }  
  
         public TrackMode TrackMode  
         {  
             get  
             {  
                 return mapControl.TrackOverlay.TrackMode;  
             }  
             set  
             {  
                 mapControl.TrackOverlay.TrackMode = value;  
             }  
         }  
  
         public void AddMarkersByQueriedFeatures(IEnumerable<Feature> queriedFeatures, PointShape startPointShape)  
         {  
             SimpleMarkerOverlay markerOverlay = (SimpleMarkerOverlay)mapControl.Overlays[Resources.MakerOverlayKey];  
             if (startPointShape != null)  
             {  
                 Marker startMarker = CreateMarker(startPointShape, Resources.drawPoint);  
                 markerOverlay.Markers.Add(startMarker);  
             }  
         }  
  
         public void ClearPoiMarkers()  
         {  
             SimpleMarkerOverlay markerOverlay = (SimpleMarkerOverlay)mapControl.Overlays[Resources.MakerOverlayKey];  
             foreach (var item in markerOverlay.Markers)  
             {  
                 item.Dispose();  
             }  
  
             markerOverlay.Markers.Clear();  
         }  
  
         public ShapeFileFeatureLayer GetCandidatePoiLayerByName(string layerName)  
         {  
             return poiLayers.FirstOrDefault(l => l.Name.Equals(layerName, StringComparison.OrdinalIgnoreCase));  
         }  
  
         public ObservableCollection<string> GetCandidatePoiLayerNames()  
         {  
             return new ObservableCollection<string>(GetCandidatePoiLayers().Select(l => l.Name));  
         }  
  
         public ObservableCollection<ShapeFileFeatureLayer> GetCandidatePoiLayers()  
         {  
             return poiLayers ?? (poiLayers = new ObservableCollection<ShapeFileFeatureLayer>  
             {  
                 HotelsLayer,  
                 MedicalFacilitesLayer,  
                 RestaurantsLayer,  
                 SchoolsLayer  
             });  
         }  
  
         public Collection<string> GetCurrentPioTypeColumnValues()  
         {  
             string columnName = GetCurrentPoiTypeColumnName();  
  
             Collection<string> columnValues = new Collection<string>();  
             if (columnName == "Hotels")  
             {  
                 columnValues.Add("1 ~ 50");  
                 columnValues.Add("50 ~ 100");  
                 columnValues.Add("100 ~ 150");  
                 columnValues.Add("150 ~ 200");  
                 columnValues.Add("200 ~ 300");  
                 columnValues.Add("300 ~ 400");  
                 columnValues.Add("400 ~ 500");  
                 columnValues.Add(">= 500");  
             }  
             else  
             {  
                 Collection<Feature> features = CurrentQueryLayer.FeatureSource.GetAllFeatures(new[] { columnName });  
                 foreach (Feature feature in features)  
                 {  
                     if (!string.IsNullOrEmpty(feature.ColumnValues[columnName]) && !columnValues.Contains(feature.ColumnValues[columnName]))  
                     {  
                         columnValues.Add(feature.ColumnValues[columnName]);  
                     }  
                 }  
             }  
  
             return columnValues;  
         }  
  
         public string GetCurrentPoiTypeColumnName()  
         {  
             string result = string.Empty;  
             if (CurrentQueryLayer == RestaurantsLayer)  
             {  
                 result = "FoodType";  
             }  
             else if (CurrentQueryLayer == MedicalFacilitesLayer  
                 || CurrentQueryLayer == SchoolsLayer)  
             {  
                 result = "TYPE";  
             }  
             else if (CurrentQueryLayer == PublicFacilitesLayer)  
             {  
                 result = "AGENCY";  
             }  
             else if (CurrentQueryLayer == HotelsLayer)  
             {  
                 result = "Hotels";  
             }  
             return result;  
         }  
  
         protected void OnPlottedPoint(PlottedPointMapModelEventArgs e)  
         {  
             EventHandler<PlottedPointMapModelEventArgs> handler = PlottedPoint;  
             if (handler != null)  
             {  
                 handler(this, e);  
             }  
         }  
  
         private static Marker CreateMarker(PointShape position, Bitmap imageSource, float offsetYRatio = 1)  
         {  
             Marker marker = new Marker(position);  
             marker.Image = imageSource;  
             marker.Size = marker.Image.Size;  
  
             marker.YOffset = -marker.Image.Height * offsetYRatio;  
             marker.XOffset = -marker.Image.Width * .5f;  
             return marker;  
         }  
  
         private static string GetToolTipsText(Feature feature)  
         {  
             string name = string.Empty;  
             string address = string.Empty;  
             string information = string.Empty;  
  
             foreach (var item in feature.ColumnValues)  
             {  
                 if (item.Key.Equals("NAME", StringComparison.InvariantCultureIgnoreCase))  
                 {  
                     name = item.Value;  
                 }  
                 else if (item.Key.Equals("ADDRESS", StringComparison.InvariantCultureIgnoreCase))  
                 {  
                     address = item.Value;  
                 }  
  
                 if (!item.Key.Equals("NAME", StringComparison.InvariantCultureIgnoreCase) && !item.Key.Equals("ADDRESS", StringComparison.InvariantCultureIgnoreCase))  
                 {  
                     information = information != string.Empty ? string.Format(CultureInfo.InvariantCulture, "{0} : {1}", item.Key, item.Value)  
                         : string.Format(CultureInfo.InvariantCulture, "{0}\n{1} : {2}", information, item.Key, item.Value);  
                 }  
             }  
  
             return string.Format(CultureInfo.InvariantCulture, "Name : {0}\n{1}\n{2}", name, address, information);  
         }  
  
         private void AddAdornmentLayers()  
         {  
             // Map Legend  
             LegendAdornmentLayer legendlayer = new LegendAdornmentLayer();  
             legendlayer.Height = 135;  
             legendlayer.Location = AdornmentLocation.LowerRight;  
             mapControl.AdornmentOverlay.Layers.Add(legendlayer);  
  
             LegendItem hotelsLayerItem = new LegendItem();  
             hotelsLayerItem.ImageStyle = HotelsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             hotelsLayerItem.TextStyle = TextStyles.NoData1(Resources.HotelsLayerKey);  
             legendlayer.LegendItems.Add(Resources.HotelsLayerKey, hotelsLayerItem);  
  
             LegendItem medicalFacilitesLayeritem = new LegendItem();  
             medicalFacilitesLayeritem.ImageStyle = MedicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             medicalFacilitesLayeritem.TextStyle = TextStyles.NoData1(Resources.MedicalFacilitesLayerKey);  
             legendlayer.LegendItems.Add(Resources.MedicalFacilitesLayerKey, medicalFacilitesLayeritem);  
  
             LegendItem publicFacilitesLayeritem = new LegendItem();  
             publicFacilitesLayeritem.ImageStyle = PublicFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             publicFacilitesLayeritem.TextStyle = TextStyles.NoData1(Resources.PublicFacilitesLayerKey);  
             legendlayer.LegendItems.Add(Resources.PublicFacilitesLayerKey, publicFacilitesLayeritem);  
  
             LegendItem restaurantsLayeritem = new LegendItem();  
             restaurantsLayeritem.ImageStyle = RestaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             restaurantsLayeritem.TextStyle = TextStyles.NoData1(Resources.RestaurantsLayerKey);  
             legendlayer.LegendItems.Add(Resources.RestaurantsLayerKey, restaurantsLayeritem);  
  
             LegendItem schoolsLayeritem = new LegendItem();  
             schoolsLayeritem.ImageStyle = SchoolsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             schoolsLayeritem.TextStyle = TextStyles.NoData1(Resources.SchoolsLayerKey);  
             legendlayer.LegendItems.Add(Resources.SchoolsLayerKey, schoolsLayeritem);  
  
             // Scale bar  
             ScaleBarAdornmentLayer scaleBar = new ScaleBarAdornmentLayer();  
             scaleBar.Location = AdornmentLocation.LowerLeft;  
             mapControl.AdornmentOverlay.Layers.Add(Resources.ScaleBarLayerKey, scaleBar);  
         }  
  
         private void AddBaseMapOverlays()  
         {  
             // Background Overlay  
             string cacheFolder = Path.Combine(Path.GetTempPath(), "TileCache");  
  
             WorldMapKitWmsDesktopOverlay worldMapKitOverlay = new WorldMapKitWmsDesktopOverlay();  
             worldMapKitOverlay.Name = Resources.WorldMapKitOverlayName;  
             worldMapKitOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             worldMapKitOverlay.IsBase = true;  
             worldMapKitOverlay.IsVisible = true;  
             worldMapKitOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitOverlayName);  
             mapControl.Overlays.Add(Resources.WorldMapKitOverlayName, worldMapKitOverlay);  
  
             OpenStreetMapOverlay openStreetMapOverlay = new OpenStreetMapOverlay();  
             openStreetMapOverlay.Name = Resources.OSMOverlayName;  
             openStreetMapOverlay.IsBase = true;  
             openStreetMapOverlay.IsVisible = false;  
             openStreetMapOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.OSMOverlayName);  
             mapControl.Overlays.Add(Resources.OSMOverlayName, openStreetMapOverlay);  
  
             BingMapsOverlay bingMapsAerialOverlay = new BingMapsOverlay();  
             bingMapsAerialOverlay.Name = Resources.BingMapsAerialOverlayName;  
             bingMapsAerialOverlay.MapType = BingMapsMapType.Aerial;  
             bingMapsAerialOverlay.IsBase = true;  
             bingMapsAerialOverlay.IsVisible = false;  
             bingMapsAerialOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsAerialOverlayName);  
             mapControl.Overlays.Add(Resources.BingMapsAerialOverlayName, bingMapsAerialOverlay);  
  
             BingMapsOverlay bingMapsRoadOverlay = new BingMapsOverlay();  
             bingMapsRoadOverlay.Name = Resources.BingMapsRoadOverlayName;  
             bingMapsRoadOverlay.MapType = BingMapsMapType.Road;  
             bingMapsRoadOverlay.IsBase = true;  
             bingMapsRoadOverlay.IsVisible = false;  
             bingMapsRoadOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsRoadOverlayName);  
             mapControl.Overlays.Add(Resources.BingMapsRoadOverlayName, bingMapsRoadOverlay);  
  
             // Custom Overlay  
             LayerOverlay customOverlay = new LayerOverlay();  
             mapControl.Overlays.Add(Resources.CustomOverlayKey, customOverlay);  
  
             Proj4Projection proj4 = new Proj4Projection();  
             proj4.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();  
             proj4.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();  
             proj4.Open();  
  
             ShapeFileFeatureLayer restrictionLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestrictedShapeFilePathName"]);  
             restrictionLayer.FeatureSource.Projection = proj4;  
  
             InMemoryFeatureLayer serviceAreaLayer = new InMemoryFeatureLayer();  
             serviceAreaLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(new GeoColor(120, GeoColor.FromHtml("#1749c9")), GeoColor.FromHtml("#fefec1"), 3, LineDashStyle.Solid);  
             serviceAreaLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             customOverlay.Layers.Add(Resources.ServiceAreaLayerKey, serviceAreaLayer);  
  
             // POI Overlay  
             LayerOverlay poiOverlay = new LayerOverlay();  
             mapControl.Overlays.Add(Resources.PoiOverlayKey, poiOverlay);  
  
             ShapeFileFeatureLayer hotelsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["HotelsShapeFilePathName"]);  
             GeoImage hotelImage = new GeoImage(@"..\..\Image\Hotel.png");  
             hotelsLayer.Name = Resources.HotelsLayerKey;  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(hotelImage);  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             hotelsLayer.FeatureSource.Projection = proj4;  
             poiOverlay.Layers.Add(Resources.HotelsLayerKey, hotelsLayer);  
  
             ShapeFileFeatureLayer medicalFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["MedicalFacilitiesShapeFilePathName"]);  
             GeoImage medicalFacilitesImage = new GeoImage(@"..\..\Image\DrugStore.png");  
             medicalFacilitesLayer.Name = Resources.MedicalFacilitesLayerKey;  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(medicalFacilitesImage);  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             medicalFacilitesLayer.FeatureSource.Projection = proj4;  
             poiOverlay.Layers.Add(Resources.MedicalFacilitesLayerKey, medicalFacilitesLayer);  
  
             ShapeFileFeatureLayer publicFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["PublicFacilitiesShapeFilePathName"]);  
             GeoImage publicFacilitesImage = new GeoImage(@"..\..\Image\public_facility.png");  
             publicFacilitesLayer.Name = Resources.PublicFacilitesLayerKey;  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(publicFacilitesImage);  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             publicFacilitesLayer.FeatureSource.Projection = proj4;  
             poiOverlay.Layers.Add(Resources.PublicFacilitesLayerKey, publicFacilitesLayer);  
  
             ShapeFileFeatureLayer restaurantsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestaurantsShapeFilePathName"]);  
             GeoImage restaurantsImage = new GeoImage(@"..\..\Image\restaurant.png");  
             restaurantsLayer.Name = Resources.RestaurantsLayerKey;  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(restaurantsImage);  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restaurantsLayer.FeatureSource.Projection = proj4;  
             poiOverlay.Layers.Add(Resources.RestaurantsLayerKey, restaurantsLayer);  
  
             ShapeFileFeatureLayer schoolsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["SchoolsShapeFilePathName"]);  
             GeoImage schoolsImage = new GeoImage(@"..\..\Image\school.png");  
             schoolsLayer.Name = Resources.SchoolsLayerKey;  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(schoolsImage);  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             schoolsLayer.FeatureSource.Projection = proj4;  
             poiOverlay.Layers.Add(Resources.SchoolsLayerKey, schoolsLayer);  
  
             // Marker Overlay for Queried POIs  
             SimpleMarkerOverlay markerOverlay = new SimpleMarkerOverlay();  
             markerOverlay.MapControl = mapControl;  
             mapControl.Overlays.Add(Resources.MakerOverlayKey, markerOverlay);  
         }  
  
         private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)  
         {  
             if (mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Count > 0)  
             {  
                 PointShape pointShape = mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures[0].GetShape() as PointShape;  
                 if (CurrentQueryLayer != null && pointShape != null)  
                 {  
                     selectedPoint = pointShape;  
                     OnPlottedPoint(new PlottedPointMapModelEventArgs(selectedPoint));  
                 }  
                 else  
                 {  
                     OnPlottedPoint(new PlottedPointMapModelEventArgs());  
                 }  
  
                 mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();  
             }  
  
         }  
     }  
 }  
 </code>


====SerializableFeature.cs====

<code csharp>   
 using System.Collections.Generic;  
 using System.Runtime.Serialization;  
 using ThinkGeo.MapSuite.Core;  
  
 namespace ThinkGeo.MapSuite.WMSServiceClient  
 {  
     [DataContract]  
     public class SerializableFeature  
     {  
         private string id;  
         private string wkt;  
         private Feature concreteFeature;  
  
         [DataMember(Name|= "fieldValues")]  
         public Dictionary<string, string> fieldValues { get; set; }  
  
         [DataMember(Name|= "id")]  
         public string Id  
         {  
             get { return id; }  
             set { id = value; }  
         }  
  
         [DataMember(Name|= "wkt")]  
         public string Wkt  
         {  
             get { return wkt; }  
             set  
             {  
                 wkt = value;  
                 concreteFeature = new Feature(wkt);  
                 foreach (var fieldValue in fieldValues)  
                 {  
                     concreteFeature.ColumnValues.Add(fieldValue.Key, fieldValue.Value);  
                 }  
             }  
         }  
  
         public Feature ConcreteFeature  
         {  
             get { return concreteFeature; }  
             set { concreteFeature = value; }  
         }  
     }  
 }  
 </code>


====MainForm.cs====

<code csharp>   
 using System;  
 using System.Collections.Generic;  
 using System.Diagnostics;  
 using System.Drawing;  
 using System.Drawing.Drawing2D;  
 using System.Globalization;  
 using System.Linq;  
 using System.Net;  
 using System.Runtime.Serialization.Json;  
 using System.Windows.Forms;  
 using System.Xml.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 using ThinkGeo.MapSuite.WMSServiceClient.Properties;  
  
 namespace ThinkGeo.MapSuite.WMSServiceClient  
 {  
     public partial class MainForm : Form  
     {  
         private static string serviceUrl = "http://localhost:52289/WmsHandler.axd";  
  
         private Proj4Projection proj4;  
         private InMemoryFeatureLayer highlightLayer;  
         private WmsRasterLayer wmsRasterLayer;  
         private SimpleMarkerOverlay markerOverlay;  
  
         public MainForm()  
         {  
             InitializeComponent();  
             InitializeUIBackground();  
         }  
  
         private void MainForm_Load(object sender, EventArgs e)  
         {  
             InitializeMap();  
             InitializeComboboxControls();  
         }  
  
         private void ClearButton_Click(object sender, EventArgs e)  
         {  
             rbtnPan.Checked = true;  
             highlightLayer.Clear();  
             ClearMarkers();  
             map.Refresh();  
         }  
  
         private void ProjectionCombobox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             if (cbxProjection.Text.Equals("DecimalDegree"))  
             {  
                 if (map.MapUnit != GeographyUnit.DecimalDegree)  
                 {  
                     map.MapUnit = GeographyUnit.DecimalDegree;  
                     map.CurrentExtent = proj4.ConvertToInternalProjection(map.CurrentExtent);  
                 }  
  
                 wmsRasterLayer.Parameters["srs"] = Resources.EPSG4326;  
             }  
             else  
             {  
                 if (map.MapUnit != GeographyUnit.Meter)  
                 {  
                     map.MapUnit = GeographyUnit.Meter;  
                     map.CurrentExtent = proj4.ConvertToExternalProjection(map.CurrentExtent);  
                 }  
  
                 wmsRasterLayer.Parameters["srs"] = Resources.EPSG900913;  
             }  
  
             map.Refresh();  
         }  
  
         private void UserNameCombobox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             rbtnPan.Checked = true;  
  
             User selectedUser = (User)cbxUserName.SelectedItem;  
             txtStyle.Text = selectedUser.MapStyle;  
             wmsRasterLayer.Parameters["ClientId"] = selectedUser.ClientId;  
             wmsRasterLayer.Parameters["UserName"] = selectedUser.UserName;  
  
             map.Refresh();  
         }  
  
         private void MapModeRadioButton_CheckedChanged(object sender, EventArgs e)  
         {  
             RadioButton radioButton = (RadioButton)sender;  
             if (rbtnDrawPoint.Checked && cbxUserName.Text.Equals("Anonymous"))  
             {  
                 MessageBox.Show("This function is not supported for anonymous, please choose another user.", "Warning");  
                 rbtnDrawPoint.Checked = false;  
                 rbtnPan.Checked = true;  
             }  
  
             map.TrackOverlay.TrackMode = rbtnPan.Checked ? TrackMode.None : TrackMode.Point;  
             radioButton.FlatAppearance.BorderColor = radioButton.Checked ? Color.FromArgb(136, 136, 136) : Color.White;  
         }  
  
         private void ViewCapabilites_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)  
         {  
             Process.Start(serviceUrl + "?SERVICE=WMS&VERSION=1.1.1&REQUEST=GetCapabilities");  
         }  
  
         private void LeftSideBarPanel_PanelCollapseButtonClick(object sender, EventArgs e)  
         {  
             map.Width = Width - leftSideBarPanel.Width - 15;  
             map.Left = leftSideBarPanel.Width;  
         }  
  
         private void Map_MouseMove(object sender, MouseEventArgs e)  
         {  
             PointShape mouseLocation = ExtentHelper.ToWorldCoordinate(map.CurrentExtent, new ScreenPointF(e.X, e.Y), map.Width, map.Height);  
             lblLocationX.Text = string.Format(CultureInfo.InvariantCulture, "X:{0:N2}", mouseLocation.X);  
             lblLocationY.Text = string.Format(CultureInfo.InvariantCulture, "Y:{0:N2}", mouseLocation.Y);  
             stpFooter.Refresh();  
         }  
  
         private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)  
         {  
             if (map.TrackOverlay.TrackShapeLayer.InternalFeatures.Count > 0)  
             {  
                 PointShape pointShape = map.TrackOverlay.TrackShapeLayer.InternalFeatures[0].GetShape() as PointShape;  
                 if (pointShape != null)  
                 {  
                     map.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();  
                     ClearMarkers();  
                     RefreshUIs(pointShape);  
                 }  
             }  
         }  
  
         private static Marker CreateMarker(PointShape position, Bitmap bitmap, float offsetYRatio = 1)  
         {  
             Marker marker = new Marker(position);  
             marker.Image = bitmap;  
             marker.Size = marker.Image.Size;  
  
             marker.YOffset = -marker.Image.Height * offsetYRatio;  
             marker.XOffset = -marker.Image.Width * .5f;  
             return marker;  
         }  
  
         private static string GetToolTipText(Feature feature)  
         {  
             string name = GetColumnValue(feature, "LONG_NAME");  
             string populationValue = GetColumnValue(feature, "POP_CNTRY");  
             if (!string.IsNullOrEmpty(populationValue))  
             {  
                 populationValue = string.Format(CultureInfo.InvariantCulture, "{0} : {1}", "Population: ", populationValue);  
             }  
             return string.Format(CultureInfo.InvariantCulture, "NAME: {0}\n{1}", name, populationValue);  
         }  
  
         private static string GetColumnValue(Feature feature, string columnName)  
         {  
             KeyValuePair<string, string> columnValuePair = feature.ColumnValues.FirstOrDefault(f => f.Key.Equals(columnName, StringComparison.InvariantCultureIgnoreCase));  
             return columnValuePair.Value;  
         }  
  
         private static List<User> GetUsers()  
         {  
             var result = XDocument.Load(@"..\..\UserDataXml\Users.xml").Descendants("User").Select(userElement => new User  
             {  
                 UserName = userElement.Element("UserName").Value,  
                 ClientId = userElement.Element("ClientId") == null ? string.Empty : userElement.Element("ClientId").Value,  
                 MapStyle = userElement.Element("MapStyle") == null ? string.Empty : userElement.Element("MapStyle").Value  
             }).ToList();  
  
             return result;  
         }  
  
         private void AddMarkersByPoint(PointShape startPointShape)  
         {  
             if (markerOverlay != null)  
             {  
                 Marker startMarker = CreateMarker(startPointShape, Resources.drawPoint);  
                 startMarker.ToolTipDelayInMilliseconds = 2000;  
                 startMarker.ToolTipText = GetToolTipText(highlightLayer.InternalFeatures.FirstOrDefault());  
                 markerOverlay.Markers.Add(startMarker);  
             }  
         }  
  
         private void ClearMarkers()  
         {  
             foreach (var marker in markerOverlay.Markers)  
             {  
                 marker.Dispose();  
             }  
  
             markerOverlay.Markers.Clear();  
         }  
  
         private string GetBoundingBoxString(RectangleShape boundingBox)  
         {  
             return String.Format(CultureInfo.InvariantCulture, "{0},{1},{2},{3}", boundingBox.LowerLeftPoint.X, boundingBox.LowerLeftPoint.Y, boundingBox.UpperRightPoint.X, boundingBox.UpperRightPoint.Y);  
         }  
  
         private void RefreshUIs(PointShape centerPoint)  
         {  
             highlightLayer.Open();  
             highlightLayer.Clear();  
  
             var screenPoint = ExtentHelper.ToScreenCoordinate(map.CurrentExtent, centerPoint.X, centerPoint.Y, map.Width, map.Height);  
             const string featureFormat = "TEXT/JSON";  
             const string mapFormat = "Png";  
             string clientId = ((User)cbxUserName.SelectedItem).ClientId;  
             const string featureCount = "1";  
             string projection = cbxProjection.Text.Equals("DecimalDegree", StringComparison.InvariantCultureIgnoreCase) ? Resources.EPSG4326 : Resources.EPSG900913;  
             string bbox = GetBoundingBoxString(map.CurrentExtent);  
  
             string getFeautreUrl = String.Format(CultureInfo.InvariantCulture,  
                 "?LAYERS=WorldMap&STYLES=DEFAULT&REQUEST=GETFEATUREINFO&QUERY_LAYERS=WorldMap&X={0}&Y={1}&INFO_FORMAT={2}&ClientId={3}&FEATURE_COUNT={4}&FORMAT={5}&SRS={6}&WIDTH={7}&HEIGHT={8}&BBOX={9}", (int)screenPoint.X, (int)screenPoint.Y, featureFormat, clientId, featureCount, mapFormat, projection, map.Width, map.Height, bbox);  
  
             WebRequest getFeatureRequest = WebRequest.Create(serviceUrl + getFeautreUrl);  
             WebResponse reponse = getFeatureRequest.GetResponse();  
             DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(SerializableFeatures[]));  
  
             try  
             {  
                 SerializableFeatures[] features = (SerializableFeatures[])serializer.ReadObject(reponse.GetResponseStream());  
                 highlightLayer.InternalFeatures.Add(features.FirstOrDefault().features.FirstOrDefault().ConcreteFeature);  
  
                 if (highlightLayer.InternalFeatures.Count > 0)  
                 {  
                     ClearMarkers();  
                     AddMarkersByPoint(centerPoint);  
                     highlightLayer.Open();  
                     map.CurrentExtent = highlightLayer.GetBoundingBox();  
                 }  
                 map.Refresh();  
             }  
             catch (Exception)  
             {  
                 MessageBox.Show("No result found, please click on the continent to try again.", "Warning");  
             }  
         }  
  
         private void SetRoundRectangleBitmap(Panel panel)  
         {  
             Bitmap bitmap = new Bitmap(panel.Size.Width, panel.Size.Height);  
             using (Graphics graphics = Graphics.FromImage(bitmap))  
             {  
                 graphics.SmoothingMode = SmoothingMode.HighQuality;  
                 Rectangle rect = new Rectangle(0, 0, bitmap.Width - 1, bitmap.Height - 1);  
                 GraphicsPath path = CreateRoundPath(rect, 10);  
                 graphics.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             }  
             panel.BackgroundImage = bitmap;  
         }  
  
         private GraphicsPath CreateRoundPath(Rectangle rect, int roundRadius)  
         {  
             GraphicsPath path = new GraphicsPath();  
  
             if (rect.Width == 0 || rect.Height == 0)  
             {  
                 return path;  
             }  
  
             if (roundRadius > 0)  
             {  
                 path.AddArc(rect.Left, rect.Top, roundRadius, roundRadius, 180, 90);  
                 path.AddArc(rect.Right - roundRadius, rect.Top, roundRadius, roundRadius, -90, 90);  
                 path.AddArc(rect.Right - roundRadius, rect.Bottom - roundRadius, roundRadius, roundRadius, 0, 90);  
                 path.AddArc(rect.Left, rect.Bottom - roundRadius, roundRadius, roundRadius, 90, 90);  
             }  
  
             path.CloseFigure();  
             return path;  
         }  
  
         private void InitializeUIBackground()  
         {  
             Bitmap headerBitmap = new Bitmap(pnlHeader.Width, pnlHeader.Height);  
             using (Graphics graphics = Graphics.FromImage(headerBitmap))  
             {  
                 Rectangle drawingRectangle = new Rectangle(0, pnlHeader.Height / 4,  
                     pnlHeader.Width, pnlHeader.Height * 2);  
                 LinearGradientBrush myBrush = new LinearGradientBrush(drawingRectangle, Color.White, Color.Gray, LinearGradientMode.Vertical);  
                 graphics.FillRectangle(myBrush, drawingRectangle);  
  
                 drawingRectangle = new Rectangle(0, pnlHeader.Height - 5, pnlHeader.Width, 5);  
                 SolidBrush solidBrush = new SolidBrush(Color.White);  
                 graphics.FillRectangle(solidBrush, drawingRectangle);  
  
                 myBrush = new LinearGradientBrush(drawingRectangle, Color.Gray, Color.White, LinearGradientMode.Vertical);  
                 graphics.FillRectangle(myBrush, drawingRectangle);  
             }  
             pnlHeader.BackgroundImage = headerBitmap;  
  
             SetRoundRectangleBitmap(pnlBuildingType);  
             SetRoundRectangleBitmap(pnlControlMode);  
         }  
  
         private void InitializeComboboxControls()  
         {  
             cbxUserName.ValueMember = "UserName";  
             cbxUserName.DataSource = GetUsers();  
  
             cbxProjection.Items.AddRange(new object[] { "DecimalDegree", "Mercator" });  
             cbxProjection.SelectedIndex = 0;  
             cbxProjection.SelectedIndexChanged += ProjectionCombobox_SelectedIndexChanged;  
  
             ToolTip panToolTip = new ToolTip();  
             panToolTip.SetToolTip(rbtnPan, "Pan the map");  
  
             ToolTip pinToolTip = new ToolTip();  
             pinToolTip.SetToolTip(rbtnDrawPoint, "Highlight a country");  
  
             ToolTip clearToolTip = new ToolTip();  
             clearToolTip.SetToolTip(btnClear, "Remove pin and selection");  
         }  
  
         private void InitializeMap()  
         {  
             map.MapUnit = GeographyUnit.DecimalDegree;  
             map.CurrentExtent = new RectangleShape(-170, 70, 170, -70);  
             map.TrackOverlay.TrackMode = TrackMode.None;  
  
             LayerOverlay baseOverlay = new LayerOverlay();  
             map.Overlays.Add(baseOverlay);  
  
             Uri uri = new Uri(serviceUrl);  
             wmsRasterLayer = new WmsRasterLayer(uri);  
             wmsRasterLayer.ActiveLayerNames.Add("WorldMap");  
             wmsRasterLayer.ActiveStyleNames.Add("DEFAULT");  
             wmsRasterLayer.Parameters.Add("crs", Resources.EPSG4326);  
             wmsRasterLayer.Parameters.Add("format", "image/png");  
             baseOverlay.Layers.Add(wmsRasterLayer);  
  
             LayerOverlay customOverlay = new LayerOverlay();  
             map.Overlays.Add(customOverlay);  
  
             highlightLayer = new InMemoryFeatureLayer();  
             highlightLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(new GeoColor(120, GeoColor.FromHtml("#1749c9")), GeoColor.FromHtml("#fefec1"), 3, LineDashStyle.Solid);  
             highlightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             customOverlay.Layers.Add(highlightLayer);  
  
             markerOverlay = new SimpleMarkerOverlay();  
             markerOverlay.MapControl = map;  
             map.Overlays.Add(markerOverlay);  
  
             map.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;  
  
             proj4 = new Proj4Projection();  
             proj4.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();  
             proj4.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();  
             proj4.Open();  
         }  
  
         private void LinkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)  
         {  
             Process.Start("http://localhost:52289/");  
         }  
     }  
 }  
 </code>

====User.cs====

<code csharp>   
  
 namespace ThinkGeo.MapSuite.WMSServiceClient  
 {  
     public class User  
     {  
         private string userName;  
         private string clientId;  
         private string mapStyle;  
  
         public string UserName  
         {  
             get { return userName; }  
             set { userName = value; }  
         }  
  
         public string ClientId  
         {  
             get { return clientId; }  
             set { clientId = value; }  
         }  
  
         public string MapStyle  
         {  
             get { return mapStyle; }  
             set { mapStyle = value; }  
         }  
     }  
 }  
 </code>
User Tools

Site Tools

Page Tools
