using System;  
 using System.Windows.Forms;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     internal static class Program  
     {  
         /// <summary>  
         /// The main entry point for the application.  
         /// </summary>  
         [STAThread]  
         private static void Main()  
         {  
             Application.EnableVisualStyles();  
             Application.SetCompatibleTextRenderingDefault(false);  
             Application.Run(new MainForm());  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Configuration;  
 using System.Drawing;  
 using System.Drawing.Drawing2D;  
 using System.Globalization;  
 using System.Linq;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public partial class MainForm : Form  
     {  
         private static readonly PointShape thinkGeoLocation = new PointShape(-10776838.0796536, 3912346.50475619);  
 
         private bool isLoad;  
         private MapModel mapModel;  
         private OverlaySwitcher switcher;  
         private AreaCreateMode createAreasMode;  
         private Collection<QueryResultItem> queryResult;  
 
         public MainForm()  
         {  
             InitializeComponent();  
             InitializeMapModel();  
             InitializeBackground();  
             InitializeOverlaySwitcher();  
         }  
 
         private void MainForm_Load(object sender, EventArgs e)  
         {  
             foreach (string name in mapModel.GetPoiLayerCandidateNames())  
             {  
                 CandidatePoiLayersComboBox.Items.Add(name);  
             }  
 
             CandidatePoiLayersComboBox.SelectedIndex = 2;  
             RouteRadioButton.Checked = true;  
             PanRadioButton.Checked = true;  
             RouteTimeTextBox.Text = Resources.MainForm_MainForm_Load__6;  
             DistanceValueTextBox.Text = Resources.MainForm_MainForm_Load__2;  
             DistanceUnitComboBox.SelectedIndex = 1;  
             isLoad = true;  
 
             ToolTip panToolTip = new ToolTip();  
             panToolTip.SetToolTip(PanRadioButton, "Pan the map");  
             ToolTip pointToolTip = new ToolTip();  
             pointToolTip.SetToolTip(rbtnDrawPoint, "Highlight a country");  
             ToolTip clearToolTip = new ToolTip();  
             clearToolTip.SetToolTip(RadioButtonClear, "Remove pin and selection");  
 
             UpdateQueryResult();  
         }  
 
         private void MapModel_PlottedPoint(object sender, PlottedPointChangedMapModelEventArgs e)  
         {  
             mapModel.PlottedPoint = e.PlottedPoint;  
             UpdateQueryResult();  
         }  
 
         private void ApplyQueryButton_Click(object sender, EventArgs e)  
         {  
             UpdateQueryResult();  
         }  
 
         private void CandidatePoiLayersComboBox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             mapModel.QueryingFeatureLayer = mapModel.GetPoiFeatureLayerByName(CandidatePoiLayersComboBox.SelectedItem.ToString());  
             UpdatePioTypeCandidates();  
         }  
 
         private void ControlMapMode_CheckedChanged(object sender, EventArgs e)  
         {  
             RadioButton radioButton = (RadioButton)sender;  
             mapModel.TrackMode = PanRadioButton.Checked ? TrackMode.None : TrackMode.Point;  
             radioButton.FlatAppearance.BorderColor = radioButton.Checked ? Color.FromArgb(136, 136, 136) : Color.White;  
         }  
 
         private void ClearRadioButton_Click(object sender, EventArgs e)  
         {  
             PanRadioButton.Checked = true;  
             RadioButtonClear.Checked = false;  
             QueryResultItemsDataGridView.Visible = false;  
 
             mapModel.ServiceAreaLayer.Clear();  
             mapModel.ClearPoiMarkers();  
             mapModel.MapControl.Refresh();  
         }  
 
         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);  
             FooterLocationXToolStripStatusLabel.Text = string.Format(CultureInfo.InvariantCulture, "X:{0:0.##}", mouseLocation.X);  
             FooterLocationYToolStripStatusLabel.Text = string.Format(CultureInfo.InvariantCulture, "Y:{0:0.##}", mouseLocation.Y);  
             stpFooter.Refresh();  
         }  
 
         private static void Switcher_OverlaySwitched(object sender, OverlayChangedOverlaySwitcherEventArgs e)  
         {  
             BingMapsOverlay bingMapsOverlay = e.Overlay as BingMapsOverlay;  
             if (bingMapsOverlay != null)  
             {  
                 string applicationId = MapSuiteSampleHelper.GetBingMapsApplicationId(bingMapsOverlay.MapType);  
 
                 if (!string.IsNullOrEmpty(applicationId)) bingMapsOverlay.ApplicationId = applicationId;  
                 else e.Cancel = true;  
             }  
         }  
 
         private void AreaTypeRadioButton_CheckedChanged(object sender, EventArgs e)  
         {  
             BufferPanel.Visible = false;  
             RoutePanel.Visible = false;  
 
             RadioButton radioButton = sender as RadioButton;  
             if (radioButton != null && radioButton.Checked)  
             {  
                 if (radioButton == RouteRadioButton)  
                 {  
                     createAreasMode = AreaCreateMode.Route;  
                     RouteRadioButton.Location = new Point(5, 12);  
                     BufferRadioButton.Location = new Point(5, 80);  
 
                     RoutePanel.Location = new Point(21, 42);  
                     RoutePanel.Visible = true;  
                 }  
                 else  
                 {  
                     createAreasMode = AreaCreateMode.Buffer;  
                     RouteRadioButton.Location = new Point(5, 12);  
                     BufferRadioButton.Location = new Point(5, 46);  
 
                     BufferPanel.Location = new Point(21, BufferRadioButton.Location.Y + BufferRadioButton.Height + 5);  
                     BufferPanel.Visible = true;  
                 }  
             }  
         }  
 
         private void DistanceValueTextBox_KeyPress(object sender, KeyPressEventArgs e)  
         {  
             int keyChar = e.KeyChar;  
             if ((keyChar < 48 || keyChar > 57) && keyChar != 8)  
             {  
                 e.Handled = true;  
             }  
         }  
 
         private void DistanceValueTextBox_TextChanged(object sender, EventArgs e)  
         {  
             double value;  
             bool isValueDouble = double.TryParse(DistanceValueTextBox.Text, out value);  
 
             if (isValueDouble && value < 1)  
             {  
                 DistanceValueTextBox.Text = value.ToString(CultureInfo.InvariantCulture);  
             }  
         }  
 
         private void QueryResultItemsDataGridView_CellClick(object sender, DataGridViewCellEventArgs e)  
         {  
             if (e.ColumnIndex != 0) return;  
 
             DataGridViewCell cell = QueryResultItemsDataGridView.Rows[e.RowIndex].Cells["Location"];  
             if (cell.Value != null)  
             {  
                 mapModel.MapControl.CurrentExtent = BaseShape.CreateShapeFromWellKnownData((string)cell.Value).GetBoundingBox();  
                 mapModel.MapControl.Refresh();  
             }  
         }  
 
         private void OverlayVisiblePictureBox_Click(object sender, EventArgs e)  
         {  
             PictureBox tempPictureBox = (PictureBox)sender;  
             tempPictureBox.Cursor = Cursors.Hand;  
             if (switcher != null)  
             {  
                 if (switcher.Visible)  
                 {  
                     switcher.Visible = false;  
                     tempPictureBox.Image = Resources.switcher_maxmize;  
                 }  
                 else  
                 {  
                     switcher.Visible = true;  
                     tempPictureBox.Image = Resources.switcher_minimize;  
                 }  
             }  
         }  
 
         private void QueryResultItemsDataGridView_CellMouseEnter(object sender, DataGridViewCellEventArgs e)  
         {  
             if (e.ColumnIndex == 0 && e.RowIndex >= 0)  
             {  
                 DataGridViewCell cell = QueryResultItemsDataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex];  
                 if (cell.Value != null)  
                 {  
                     cell.Style.BackColor = Color.LightBlue;  
                 }  
             }  
         }  
 
         private void QueryResultItemsDataGridView_CellMouseLeave(object sender, DataGridViewCellEventArgs e)  
         {  
             if (e.ColumnIndex == 0 && e.RowIndex >= 0)  
             {  
                 DataGridViewCell cell = QueryResultItemsDataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex];  
                 if (cell.Value != null)  
                 {  
                     cell.Style.BackColor = Color.White;  
                 }  
             }  
         }  
 
         private void RouteTimeTextBox_KeyPress(object sender, KeyPressEventArgs e)  
         {  
             int keyChar = e.KeyChar;  
             if (keyChar == 46)  
             {  
                 if (DistanceValueTextBox.Text.Length <= 0)  
                 {  
                     e.Handled = true;  
                 }  
                 else  
                 {  
                     double value;  
                     double oldValue;  
                     bool isOldValueDouble = double.TryParse(DistanceValueTextBox.Text, out oldValue);  
                     bool isNewValueDouble = double.TryParse(DistanceValueTextBox.Text + e.KeyChar.ToString(CultureInfo.InvariantCulture), out value);  
                     if (isNewValueDouble == false)  
                     {  
                         e.Handled = isOldValueDouble;  
                     }  
                 }  
             }  
             else if ((keyChar < 48 || keyChar > 57) && keyChar != 8)  
             {  
                 e.Handled = true;  
             }  
         }  
 
         private void InitializeMapModel()  
         {  
             queryResult = new Collection<QueryResultItem>();  
 
             mapModel = new MapModel(map);  
             mapModel.PlottedPoint = thinkGeoLocation;  
             mapModel.PlottedPointChanged += MapModel_PlottedPoint;  
         }  
 
         private void InitializeOverlaySwitcher()  
         {  
             Collection<Overlay> baseOverlays = new Collection<Overlay>();  
             baseOverlays.Add(map.Overlays[Resources.WorldMapKitOverlayName]);  
             baseOverlays.Add(map.Overlays[Resources.OSMOverlayName]);  
             baseOverlays.Add(map.Overlays[Resources.BingMapsAerialOverlayName]);  
             baseOverlays.Add(map.Overlays[Resources.BingMapsRoadOverlayName]);  
 
             switcher = new OverlaySwitcher(baseOverlays, map);  
             switcher.Anchor = AnchorStyles.Right | AnchorStyles.Top;  
             switcher.Location = new Point(Width - 203, 55);  
             switcher.Size = new Size(185, 90);  
             switcher.OverlayChanged += Switcher_OverlaySwitched;  
             Controls.Add(switcher);  
             switcher.BringToFront();  
 
             PictureBox overlayVisiblePictureBox = new PictureBox();  
             overlayVisiblePictureBox.Anchor = AnchorStyles.Right | AnchorStyles.Top;  
             overlayVisiblePictureBox.Image = Resources.switcher_minimize;  
             overlayVisiblePictureBox.SizeMode = PictureBoxSizeMode.AutoSize;  
             overlayVisiblePictureBox.Location = new Point(switcher.Location.X + switcher.Width - overlayVisiblePictureBox.Width - 8, switcher.Location.Y + 5);  
             overlayVisiblePictureBox.Click += OverlayVisiblePictureBox_Click;  
             Controls.Add(overlayVisiblePictureBox);  
             overlayVisiblePictureBox.BringToFront();  
             switcher.Refresh();  
         }  
 
         private void InitializeBackground()  
         {  
             Bitmap buildingTypeBitmap = new Bitmap(pnlBuildingType.Size.Width, pnlBuildingType.Size.Height);  
             using (Graphics graphics = Graphics.FromImage(buildingTypeBitmap))  
             {  
                 graphics.SmoothingMode = SmoothingMode.HighQuality;  
                 Rectangle rect = new Rectangle(0, 0, buildingTypeBitmap.Width - 1, buildingTypeBitmap.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 graphics.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             }  
             pnlBuildingType.BackgroundImage = buildingTypeBitmap;  
 
             Bitmap controlModeBitmap = new Bitmap(pnlControlMode.Size.Width, pnlControlMode.Size.Height);  
             using (Graphics graphics = Graphics.FromImage(controlModeBitmap))  
             {  
                 graphics.SmoothingMode = SmoothingMode.HighQuality;  
                 Rectangle rect = new Rectangle(0, 0, controlModeBitmap.Width - 1, controlModeBitmap.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 graphics.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             }  
             pnlControlMode.BackgroundImage = controlModeBitmap;  
 
             Bitmap areaTypeBitmap = new Bitmap(AreaTypePanel.Size.Width, AreaTypePanel.Size.Height);  
             using (Graphics graphics = Graphics.FromImage(areaTypeBitmap))  
             {  
                 graphics.SmoothingMode = SmoothingMode.HighQuality;  
                 Rectangle rect = new Rectangle(0, 0, areaTypeBitmap.Width - 1, areaTypeBitmap.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 graphics.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             }  
             AreaTypePanel.BackgroundImage = areaTypeBitmap;  
         }  
 
         private void UpdatePioTypeCandidates()  
         {  
             CandidatePoiTypesComboBox.Items.Clear();  
             CandidatePoiTypesComboBox.Items.Add(Resources.FindAllText);  
             foreach (var candidateColumnValue in mapModel.GetColumnValueCandidates())  
             {  
                 CandidatePoiTypesComboBox.Items.Add(candidateColumnValue);  
             }  
 
             CandidatePoiTypesComboBox.SelectedIndex = 0;  
         }  
 
         private void UpdateQueryResultDataGrid(IEnumerable<Feature> queryResults)  
         {  
             QueryResultItemsDataGridView.Visible = true;  
             QueryResultItemsDataGridView.Rows.Clear();  
             foreach (QueryResultItem item in queryResults.Select(f => new QueryResultItem(f)))  
             {  
                 DataGridViewRow newRow = new DataGridViewRow();  
                 newRow.Cells.Add(item.ImageButtonCell);  
                 newRow.Cells.Add(item.TextCell);  
                 newRow.Cells.Add(item.LocationCell);  
                 QueryResultItemsDataGridView.Rows.Add(newRow);  
             }  
         }  
 
         private void UpdateQueryResult()  
         {  
             if (!isLoad) return;  
 
             mapModel.QueryingFeatureLayer.Open();  
             mapModel.ServiceAreaLayer.Open();  
 
             Dictionary<string, object> parameters = GetServiceAreaAnalysisParameters();  
             ServiceAreaAnalysis serviceAreaAnalysis = MapSuiteSampleHelper.GetAreaAnalysis(createAreasMode);  
             Feature serviceAreaResult = serviceAreaAnalysis.CreateServiceAreaFeature(mapModel.PlottedPoint, mapModel.MapControl.MapUnit, parameters);  
 
             mapModel.ServiceAreaLayer.Clear();  
             mapModel.ServiceAreaLayer.InternalFeatures.Add(serviceAreaResult);  
 
             if (mapModel.ServiceAreaLayer.InternalFeatures.Count > 0)  
             {  
                 queryResult.Clear();  
                 Collection<Feature> queriedFeatures = GetQueryResultFeatures();  
                 UpdateQueryResultDataGrid(queriedFeatures);  
 
                 mapModel.AddMarkersByFeatures(queriedFeatures);  
                 mapModel.MapControl.CurrentExtent = mapModel.ServiceAreaLayer.GetBoundingBox();  
                 mapModel.MapControl.Refresh();  
             }  
         }  
 
         private IEnumerable<Feature> GetFiltedHotelFeatures(IEnumerable<Feature> hotelFeatures)  
         {  
             Collection<Feature> filteredHotelFeatures = new Collection<Feature>();  
             string property = ((string)CandidatePoiTypesComboBox.SelectedItem).Trim();  
             string[] values = property.Split('~');  
 
             double min;  
             double max;  
             double.TryParse(values[0], out min);  
             double.TryParse(values[1], out max);  
 
             foreach (Feature feature in hotelFeatures)  
             {  
                 double columnValue;  
                 if (double.TryParse(feature.ColumnValues["ROOMS"], out columnValue) && columnValue >= min && columnValue < max)  
                 {  
                     filteredHotelFeatures.Add(feature);  
                 }  
                 else if (string.IsNullOrEmpty(feature.ColumnValues["ROOMS"]))  
                 {  
                     filteredHotelFeatures.Add(feature);  
                 }  
             }  
 
             return filteredHotelFeatures;  
         }  
 
         private Dictionary<string, object> GetServiceAreaAnalysisParameters()  
         {  
             Dictionary<string, object> parameters = new Dictionary<string, object>();  
             switch (createAreasMode)  
             {  
                 case AreaCreateMode.Buffer:  
                     parameters[Resources.DistanceUnitKey] = DistanceUnitComboBox.SelectedIndex == 1 ? DistanceUnit.Mile : DistanceUnit.Kilometer;  
 
                     double distance;  
                     if (double.TryParse(DistanceValueTextBox.Text, out distance))  
                     {  
                         parameters[Resources.DistanceKey] = distance;  
                     }  
                     break;  
 
                 case AreaCreateMode.Route:  
                     parameters[Resources.StreetShapePathFilenameKey] =  
                         ConfigurationManager.AppSettings["StreetShapeFilePathName"];  
 
                     int driveTimeInMinutes;  
                     if (int.TryParse(RouteTimeTextBox.Text, out driveTimeInMinutes))  
                     {  
                         parameters[Resources.DriveTimeInMinutesKey] = driveTimeInMinutes;  
                     }  
                     break;  
             }  
             return parameters;  
         }  
 
         private Collection<Feature> GetQueryResultFeatures()  
         {  
             Collection<Feature> queryResultFeatures = new Collection<Feature>();  
             if (mapModel.ServiceAreaLayer.InternalFeatures.Count == 0) return queryResultFeatures;  
 
             BaseShape serviceAreaShape = mapModel.ServiceAreaLayer.InternalFeatures[0].GetShape();  
             Collection<Feature> selectedFeatures = mapModel.QueryingFeatureLayer.QueryTools.GetFeaturesWithin(serviceAreaShape, ReturningColumnsType.AllColumns);  
 
             if (CandidatePoiTypesComboBox.SelectedItem.ToString().Equals(Resources.FindAllText, StringComparison.OrdinalIgnoreCase))  
             {  
                 foreach (Feature feature in selectedFeatures)  
                 {  
                     queryResultFeatures.Add(feature);  
                 }  
             }  
             else if (mapModel.QueryingFeatureLayer != mapModel.HotelsLayer)  
             {  
                 string columnName = MapSuiteSampleHelper.GetDefaultColumnNameByPoiType(mapModel.QueryingFeatureLayer.Name);  
                 foreach (Feature feature in selectedFeatures)  
                 {  
                     if (feature.ColumnValues[columnName] == CandidatePoiTypesComboBox.SelectedItem.ToString()  
                         || string.IsNullOrEmpty(feature.ColumnValues[columnName]))  
                     {  
                         queryResultFeatures.Add(feature);  
                     }  
                 }  
             }  
             else  
             {  
                 IEnumerable<Feature> filteredHotelItems = GetFiltedHotelFeatures(selectedFeatures);  
                 foreach (var feature in filteredHotelItems)  
                 {  
                     queryResultFeatures.Add(feature);  
                 }  
             }  
 
             return queryResultFeatures;  
         }  
     }  
 }  
 

 using System.Collections.Generic;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class BufferServiceAreaAnalysis : ServiceAreaAnalysis  
     {  
         public BufferServiceAreaAnalysis()  
         { }  
 
         public override AreaBaseShape CreateServiceArea(PointShape pointShape, GeographyUnit geographyUnit,  
             IDictionary<string, object> parameters)  
         {  
             double distance = 2;  
             DistanceUnit distanceUnit = DistanceUnit.Mile;  
 
             if (parameters.ContainsKey(Resources.DistanceUnitKey)) distanceUnit = (DistanceUnit)parameters[Resources.DistanceUnitKey];  
             if (parameters.ContainsKey(Resources.DistanceKey)) distance = (double)parameters[Resources.DistanceKey];  
             return pointShape.Buffer(distance, 40, geographyUnit, distanceUnit);  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.IO;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.Routing;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class RouteAccessibleAreaAnalysis : ServiceAreaAnalysis  
     {  
         public RouteAccessibleAreaAnalysis()  
         { }  
 
         public override AreaBaseShape CreateServiceArea(PointShape pointShape, GeographyUnit geographyUnit, IDictionary<string, object> parameters)  
         {  
             int tempDrivingTimeInMinutes = 6;  
             string streetShapePathFilename = (string)parameters[Resources.StreetShapePathFilenameKey];  
             if (parameters.ContainsKey(Resources.DriveTimeInMinutesKey)) tempDrivingTimeInMinutes = (int)parameters[Resources.DriveTimeInMinutesKey];  
 
             string rtgFilePathName = Path.ChangeExtension(streetShapePathFilename, ".rtg");  
             RtgRoutingSource routingSource = new RtgRoutingSource(rtgFilePathName);  
             FeatureSource featureSource = new ShapeFileFeatureSource(streetShapePathFilename);  
             RoutingEngine routingEngine = new RoutingEngine(routingSource, featureSource);  
 
             ManagedProj4Projection projection = new ManagedProj4Projection();  
             projection.InternalProjectionParametersString = ManagedProj4Projection.GetBingMapParametersString();  
             projection.ExternalProjectionParametersString = ManagedProj4Projection.GetEpsgParametersString(4326);  
 
             projection.Open();  
             featureSource.Open();  
             pointShape = projection.ConvertToExternalProjection(pointShape) as PointShape;  
             Feature feature = featureSource.GetFeaturesNearestTo(pointShape, geographyUnit, 1, ReturningColumnsType.NoColumns)[0];  
             PolygonShape polygonShape = routingEngine.GenerateServiceArea(feature.Id, new TimeSpan(0, tempDrivingTimeInMinutes, 0), 100, GeographyUnit.Feet);  
             polygonShape = (PolygonShape)projection.ConvertToInternalProjection(polygonShape);  
             projection.Close();  
 
             return polygonShape;  
         }  
     }  
 }  
 

 using System.Collections.Generic;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public abstract class ServiceAreaAnalysis  
     {  
         protected ServiceAreaAnalysis()  
         { }  
 
         public Feature CreateServiceAreaFeature(PointShape pointShape, GeographyUnit geographyUnit,  
             IDictionary<string, object> parameters)  
         {  
             AreaBaseShape areaShape = CreateServiceArea(pointShape, geographyUnit, parameters);  
             return new Feature(areaShape);  
         }  
 
         public abstract AreaBaseShape CreateServiceArea(PointShape pointShape, GeographyUnit geographyUnit, IDictionary<string, object> parameters);  
     }  
 }  
 

 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public enum AreaCreateMode  
     {  
         Buffer,  
         Route  
     }  
 }  
 

 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 System.Text;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class MapModel  
     {  
         private WinformsMap mapControl;  
         private PointShape plottedPoint;  
         private BaseShape restrictionShape;  
         private ShapeFileFeatureLayer queryingFeatureLayer;  
         private ObservableCollection<ShapeFileFeatureLayer> poiLayers;  
 
         public event EventHandler<PlottedPointChangedMapModelEventArgs> PlottedPointChanged;  
 
         public MapModel()  
             : this(null)  
         { }  
 
         public MapModel(WinformsMap winformsMap)  
             : base()  
         {  
             mapControl = winformsMap;  
 
             InitializeMapControl();  
             InitializeOverlays();  
             InitializeAdornments();  
 
             mapControl.Refresh();  
         }  
 
         public WinformsMap MapControl  
         {  
             get { return mapControl; }  
         }  
 
         public PointShape PlottedPoint  
         {  
             get { return plottedPoint; }  
             set { plottedPoint = value; }  
         }  
 
         public ShapeFileFeatureLayer QueryingFeatureLayer  
         {  
             get { return queryingFeatureLayer; }  
             set { queryingFeatureLayer = value; }  
         }  
 
         public ShapeFileFeatureLayer HotelsLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.HotelsLayerKey];  
             }  
         }  
 
         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 RestrictionLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.CustomOverlayKey];  
                 return overlay.Layers[Resources.RestrictionLayerKey] as ShapeFileFeatureLayer;  
             }  
         }  
 
         public ShapeFileFeatureLayer SchoolsLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (ShapeFileFeatureLayer)overlay.Layers[Resources.SchoolsLayerKey];  
             }  
         }  
 
         public InMemoryFeatureLayer HighlightFeautreLayer  
         {  
             get  
             {  
                 LayerOverlay overlay = (LayerOverlay)mapControl.Overlays[Resources.PoiOverlayKey];  
                 return (InMemoryFeatureLayer)overlay.Layers[Resources.HighlightFeatureLayerKey];  
             }  
         }  
 
         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 AddMarkersByFeatures(IEnumerable<Feature> features)  
         {  
             ClearPoiMarkers();  
 
             SimpleMarkerOverlay markerOverlay = (SimpleMarkerOverlay)mapControl.Overlays[Resources.MakerOverlayKey];  
             HighlightFeautreLayer.InternalFeatures.Clear();  
             HighlightFeautreLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = queryingFeatureLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             if (plottedPoint != null)  
             {  
                 Marker plottedMarker = CreateMarker(plottedPoint, Resources.drawPoint);  
                 markerOverlay.Markers.Add(plottedMarker);  
             }  
             if (features != null)  
             {  
                 foreach (Feature feature in features)  
                 {  
                     HighlightFeautreLayer.InternalFeatures.Add(feature);  
                     Marker marker = CreateMarker((PointShape)feature.GetShape(), Resources.selectedHalo, .5f);  
                     marker.ToolTipDelayInMilliseconds = 2000;  
                     marker.ToolTipText = GetToolTipsText(feature);  
                     markerOverlay.Markers.Add(marker);  
                 }  
             }  
         }  
 
         public void ClearPoiMarkers()  
         {  
             SimpleMarkerOverlay markerOverlay = (SimpleMarkerOverlay)mapControl.Overlays[Resources.MakerOverlayKey];  
             foreach (var item in markerOverlay.Markers)  
             {  
                 item.Dispose();  
             }  
 
             markerOverlay.Markers.Clear();  
         }  
 
         public ShapeFileFeatureLayer GetPoiFeatureLayerByName(string layerName)  
         {  
             return poiLayers.FirstOrDefault(l => l.Name.Equals(layerName, StringComparison.OrdinalIgnoreCase));  
         }  
 
         public ObservableCollection<string> GetPoiLayerCandidateNames()  
         {  
             return new ObservableCollection<string>(GetPoiLayerCandidates().Select(l => l.Name));  
         }  
 
         public ObservableCollection<ShapeFileFeatureLayer> GetPoiLayerCandidates()  
         {  
             return poiLayers ?? (poiLayers = new ObservableCollection<ShapeFileFeatureLayer>  
             {  
                 HotelsLayer,  
                 MedicalFacilitesLayer,  
                 RestaurantsLayer,  
                 SchoolsLayer  
             });  
         }  
 
         public Collection<string> GetColumnValueCandidates()  
         {  
             string columnName = MapSuiteSampleHelper.GetDefaultColumnNameByPoiType(QueryingFeatureLayer.Name);  
 
             Collection<string> columnValues = new Collection<string>();  
             if (columnName.Equals("Hotels", StringComparison.OrdinalIgnoreCase))  
             {  
                 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  
             {  
                 QueryingFeatureLayer.Open();  
                 IEnumerable<string> distinctColumnValues = QueryingFeatureLayer.FeatureSource.GetDistinctColumnValues(columnName).Select(v => v.ColumnValue);  
                 foreach (var distinctColumnValue in distinctColumnValues)  
                 {  
                     columnValues.Add(distinctColumnValue);  
                 }  
             }  
 
             return columnValues;  
         }  
 
         protected void OnPlottedPointChanged(PlottedPointChangedMapModelEventArgs e)  
         {  
             EventHandler<PlottedPointChangedMapModelEventArgs> handler = PlottedPointChanged;  
             if (handler != null)  
             {  
                 handler(this, e);  
             }  
         }  
 
         private void InitializeMapControl()  
         {  
             mapControl.MapUnit = GeographyUnit.Meter;  
             mapControl.CurrentExtent = new RectangleShape(-10782584.5066971, 3916291.54400321, -10769504.2529497, 3907774.56943023);  
             mapControl.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;  
         }  
 
         private void InitializeAdornments()  
         {  
             mapControl.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;  
             mapControl.AdornmentOverlay.ShowLogo = false;  
 
             LegendAdornmentLayer legendlayer = new LegendAdornmentLayer();  
             legendlayer.Height = 135;  
             legendlayer.Location = AdornmentLocation.LowerRight;  
             mapControl.AdornmentOverlay.Layers.Add(legendlayer);  
 
             AddLegendItem(HotelsLayer, legendlayer);  
             AddLegendItem(MedicalFacilitesLayer, legendlayer);  
             AddLegendItem(PublicFacilitesLayer, legendlayer);  
             AddLegendItem(RestaurantsLayer, legendlayer);  
             AddLegendItem(SchoolsLayer, legendlayer);  
 
             ScaleBarAdornmentLayer scaleBar = new ScaleBarAdornmentLayer();  
             scaleBar.Location = AdornmentLocation.LowerLeft;  
             mapControl.AdornmentOverlay.Layers.Add(Resources.ScaleBarLayerKey, scaleBar);  
         }  
 
         private void InitializeOverlays()  
         {  
             string cacheFolder = Path.Combine(Path.GetTempPath(), "TileCache");  
             WorldMapKitWmsDesktopOverlay worldMapKitOverlay = new WorldMapKitWmsDesktopOverlay();  
             worldMapKitOverlay.Name = Resources.WorldMapKitOverlayName;  
             worldMapKitOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             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.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.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.IsVisible = false;  
             bingMapsRoadOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsRoadOverlayName);  
             mapControl.Overlays.Add(Resources.BingMapsRoadOverlayName, bingMapsRoadOverlay);  
 
             LayerOverlay customOverlay = new LayerOverlay();  
             mapControl.Overlays.Add(Resources.CustomOverlayKey, customOverlay);  
 
             Proj4Projection wgs84ToMercatorProjection = new Proj4Projection();  
             wgs84ToMercatorProjection.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();  
             wgs84ToMercatorProjection.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();  
             wgs84ToMercatorProjection.Open();  
 
             ShapeFileFeatureLayer restrictionLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestrictedShapeFilePathName"]);  
             restrictionLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
 
             AreaStyle extentStyle = new AreaStyle();  
             extentStyle.CustomAreaStyles.Add(new AreaStyle(new GeoSolidBrush(GeoColor.SimpleColors.Transparent)) { OutlinePen = new GeoPen(GeoColor.SimpleColors.White, 5.5f) });  
             extentStyle.CustomAreaStyles.Add(new AreaStyle(new GeoSolidBrush(GeoColor.SimpleColors.Transparent)) { OutlinePen = new GeoPen(GeoColor.SimpleColors.Red, 1.5f) { DashStyle = LineDashStyle.Dash } });  
             restrictionLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = extentStyle;  
             restrictionLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             customOverlay.Layers.Add(Resources.RestrictionLayerKey, restrictionLayer);  
 
             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);  
 
             LayerOverlay poiOverlay = new LayerOverlay();  
             mapControl.Overlays.Add(Resources.PoiOverlayKey, poiOverlay);  
 
             ShapeFileFeatureLayer hotelsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["HotelsShapeFilePathName"]);  
             hotelsLayer.Name = Resources.HotelsLayerKey;  
             hotelsLayer.Transparency = 120f;  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\Hotel.png"));  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             hotelsLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
             poiOverlay.Layers.Add(Resources.HotelsLayerKey, hotelsLayer);  
 
             ShapeFileFeatureLayer medicalFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["MedicalFacilitiesShapeFilePathName"]);  
             medicalFacilitesLayer.Name = Resources.MedicalFacilitesLayerKey;  
             medicalFacilitesLayer.Transparency = 120f;  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\DrugStore.png"));  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             medicalFacilitesLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
             poiOverlay.Layers.Add(Resources.MedicalFacilitesLayerKey, medicalFacilitesLayer);  
 
             ShapeFileFeatureLayer publicFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["PublicFacilitiesShapeFilePathName"]);  
             publicFacilitesLayer.Name = Resources.PublicFacilitesLayerKey;  
             publicFacilitesLayer.Transparency = 120f;  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\public_facility.png"));  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             publicFacilitesLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
             poiOverlay.Layers.Add(Resources.PublicFacilitesLayerKey, publicFacilitesLayer);  
 
             ShapeFileFeatureLayer restaurantsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestaurantsShapeFilePathName"]);  
             restaurantsLayer.Name = Resources.RestaurantsLayerKey;  
             restaurantsLayer.Transparency = 120f;  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\restaurant.png"));  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restaurantsLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
             poiOverlay.Layers.Add(Resources.RestaurantsLayerKey, restaurantsLayer);  
 
             ShapeFileFeatureLayer schoolsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["SchoolsShapeFilePathName"]);  
             schoolsLayer.Name = Resources.SchoolsLayerKey;  
             schoolsLayer.Transparency = 120f;  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\school.png"));  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             schoolsLayer.FeatureSource.Projection = wgs84ToMercatorProjection;  
             poiOverlay.Layers.Add(Resources.SchoolsLayerKey, schoolsLayer);  
 
             InMemoryFeatureLayer highlightFeatureLayer = new InMemoryFeatureLayer();  
             highlightFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             poiOverlay.Layers.Add(Resources.HighlightFeatureLayerKey, highlightFeatureLayer);  
 
             SimpleMarkerOverlay markerOverlay = new SimpleMarkerOverlay();  
             markerOverlay.MapControl = mapControl;  
             mapControl.Overlays.Add(Resources.MakerOverlayKey, markerOverlay);  
         }  
 
         private BaseShape GetRestrictionShape()  
         {  
             if (restrictionShape == null)  
             {  
                 LayerOverlay customOverlay = (LayerOverlay)mapControl.Overlays[Resources.CustomOverlayKey];  
                 ShapeFileFeatureLayer restictionLayer = (ShapeFileFeatureLayer)customOverlay.Layers[Resources.RestrictionLayerKey];  
 
                 restictionLayer.Open();  
                 Feature firstFeature = restictionLayer.QueryTools.GetFeatureById("1", ReturningColumnsType.NoColumns);  
                 restrictionShape = firstFeature.GetShape();  
             }  
 
             return restrictionShape;  
         }  
 
         private void TrackOverlay_TrackEnded(object sender, TrackEndedTrackInteractiveOverlayEventArgs e)  
         {  
             if (mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Count > 0)  
             {  
                 BaseShape tempRestrictionShape = GetRestrictionShape();  
                 PointShape pointShape = mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures[0].GetShape() as PointShape;  
                 if (QueryingFeatureLayer != null && pointShape != null && tempRestrictionShape != null && pointShape.IsWithin(tempRestrictionShape))  
                 {  
                     plottedPoint = pointShape;  
                     OnPlottedPointChanged(new PlottedPointChangedMapModelEventArgs(plottedPoint));  
                 }  
                 else  
                 {  
                     MessageBox.Show(Resources.SearchOutOfBoundaryMessage, Resources.WarningText, MessageBoxButtons.OK, MessageBoxIcon.Information);  
                 }  
 
                 mapControl.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();  
             }  
         }  
 
         private static void AddLegendItem(FeatureLayer featureLayer, LegendAdornmentLayer legendLayer)  
         {  
             LegendItem layerItem = new LegendItem();  
             layerItem.ImageStyle = featureLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle;  
             layerItem.TextStyle = TextStyles.NoData1(featureLayer.Name);  
             legendLayer.LegendItems.Add(featureLayer.Name, layerItem);  
         }  
 
         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;  
             StringBuilder information = new StringBuilder();  
 
             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;  
                 }  
                 else  
                 {  
                     information.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0} : {1}", item.Key, item.Value));  
                 }  
             }  
 
             return string.Format(CultureInfo.InvariantCulture, "Name : {0}\n{1}\n{2}", name, address, information);  
         }  
     }  
 }  
 

 using System;  
 using System.Drawing;  
 using System.Linq;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class QueryResultItem  
     {  
         private string name;  
         private string location;  
         private Feature feature;  
         private DataGridViewImageCell imageButtonCell;  
         private DataGridViewTextBoxCell textCell;  
         private DataGridViewTextBoxCell locationCell;  
 
         public QueryResultItem()  
             : this(null)  
         { }  
 
         public QueryResultItem(Feature feature)  
             : base()  
         {  
             this.feature = feature;  
             this.name = feature.ColumnValues.FirstOrDefault(item => item.Key.Equals("NAME", StringComparison.InvariantCultureIgnoreCase)).Value;  
             this.location = feature.GetWellKnownText();  
         }  
 
         public Feature Feature  
         {  
             get { return feature; }  
         }  
 
         public DataGridViewImageCell ImageButtonCell  
         {  
             get  
             {  
                 if (imageButtonCell == null)  
                 {  
                     imageButtonCell = new DataGridViewImageCell();  
                     imageButtonCell.Style.SelectionBackColor = Color.Transparent;  
                     imageButtonCell.Value = Icon.FromHandle(Resources.find.GetHicon());  
                 }  
 
                 return imageButtonCell;  
             }  
         }  
 
         public DataGridViewTextBoxCell TextCell  
         {  
             get { return textCell ?? (textCell = new DataGridViewTextBoxCell { Value = name }); }  
         }  
 
         public DataGridViewTextBoxCell LocationCell  
         {  
             get { return locationCell ?? (locationCell = new DataGridViewTextBoxCell { Value = location }); }  
         }  
     }  
 }  
 

 using System;  
 using System.Configuration;  
 using System.Drawing;  
 using System.Drawing.Drawing2D;  
 using System.Globalization;  
 using System.IO;  
 using System.Net;  
 using System.Windows.Forms;  
 using System.Xml;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public static class MapSuiteSampleHelper  
     {  
         private static readonly string bingLoginServiceTemplate = "http://dev.virtualearth.net/REST/v1/Imagery/Metadata/{0}?&incl=ImageryProviders&o=xml&key={1}";  
 
         public static GraphicsPath CreateRoundPath(Rectangle rect, int arcRadius)  
         {  
             GraphicsPath path = new GraphicsPath();  
 
             if (rect.Width == 0 || rect.Height == 0)  
             {  
                 return path;  
             }  
 
             if (arcRadius > 0)  
             {  
                 path.AddArc(rect.Left, rect.Top, arcRadius, arcRadius, 180, 90);  
                 path.AddArc(rect.Right - arcRadius, rect.Top, arcRadius, arcRadius, -90, 90);  
                 path.AddArc(rect.Right - arcRadius, rect.Bottom - arcRadius, arcRadius, arcRadius, 0, 90);  
                 path.AddArc(rect.Left, rect.Bottom - arcRadius, arcRadius, arcRadius, 90, 90);  
             }  
 
             path.CloseFigure();  
             return path;  
         }  
 
         public static ServiceAreaAnalysis GetAreaAnalysis(AreaCreateMode createAreaMode)  
         {  
             ServiceAreaAnalysis serviceAreaAnalysis;  
             switch (createAreaMode)  
             {  
                 case AreaCreateMode.Route:  
                     serviceAreaAnalysis = new RouteAccessibleAreaAnalysis();  
                     break;  
 
                 default:  
                     serviceAreaAnalysis = new BufferServiceAreaAnalysis();  
                     break;  
             }  
 
             return serviceAreaAnalysis;  
         }  
 
         public static string GetBingMapsApplicationId(BingMapsMapType mapType)  
         {  
             string exePath = Application.ExecutablePath;  
             Configuration config = ConfigurationManager.OpenExeConfiguration(exePath);  
             KeyValueConfigurationElement appMapKeySetting = config.AppSettings.Settings["BingMapKey"];  
             string bingMapsKey = appMapKeySetting != null ? appMapKeySetting.Value : string.Empty;  
             if (string.IsNullOrEmpty(bingMapsKey))  
             {  
                 BingMapsApplicationIdPromptForm inputBingMapKeyWindow = new BingMapsApplicationIdPromptForm();  
                 inputBingMapKeyWindow.StartPosition = FormStartPosition.CenterParent;  
                 if (inputBingMapKeyWindow.ShowDialog() == DialogResult.OK  
                     && IsBingMapsKeyValid(inputBingMapKeyWindow.ApplicationId, mapType))  
                 {  
                     bingMapsKey = inputBingMapKeyWindow.ApplicationId;  
                     config.AppSettings.Settings.Add("BingMapKey", bingMapsKey);  
                     config.Save();  
                     ConfigurationManager.RefreshSection("appSettings");  
                 }  
             }  
             return bingMapsKey;  
         }  
 
         public static string GetDefaultColumnNameByPoiType(string poiType)  
         {  
             string result = string.Empty;  
             if (poiType.Equals(Resources.RestaurantsLayerKey, StringComparison.OrdinalIgnoreCase))  
             {  
                 result = "FoodType";  
             }  
             else if (poiType.Equals(Resources.MedicalFacilitesLayerKey, StringComparison.OrdinalIgnoreCase)  
                 || poiType.Equals(Resources.SchoolsLayerKey, StringComparison.OrdinalIgnoreCase))  
             {  
                 result = "TYPE";  
             }  
             else if (poiType.Equals(Resources.PublicFacilitesLayerKey, StringComparison.OrdinalIgnoreCase))  
             {  
                 result = "AGENCY";  
             }  
             else if (poiType.Equals(Resources.HotelsLayerKey, StringComparison.OrdinalIgnoreCase))  
             {  
                 result = "Hotels";  
             }  
             return result;  
         }  
 
         private static bool IsBingMapsKeyValid(string bingMapsKey, BingMapsMapType mapType)  
         {  
             bool isValid = false;  
 
             try  
             {  
                 string loginServiceUri = String.Format(CultureInfo.InvariantCulture  
                               , bingLoginServiceTemplate, mapType, bingMapsKey);  
 
                 WebRequest request = WebRequest.Create(loginServiceUri);  
                 WebResponse response = request.GetResponse();  
                 Stream stream = response.GetResponseStream();  
                 XmlDocument xDoc = new XmlDocument();  
                 xDoc.Load(stream);  
                 XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(xDoc.NameTable);  
                 xmlNamespaceManager.AddNamespace("bing", "http://schemas.microsoft.com/search/local/ws/rest/v1");  
 
                 XmlNode root = xDoc.SelectSingleNode("bing:Response", xmlNamespaceManager);  
                 XmlNode imageUrlElement = root.SelectSingleNode("bing:ResourceSets/bing:ResourceSet/bing:Resources/bing:ImageryMetadata/bing:ImageUrl", xmlNamespaceManager);  
                 XmlNodeList subdomainsElement  
                     = root.SelectNodes("bing:ResourceSets/bing:ResourceSet/bing:Resources/bing:ImageryMetadata/bing:ImageUrlSubdomains/bing:string", xmlNamespaceManager);  
 
                 if (imageUrlElement != null && subdomainsElement != null)  
                 {  
                     isValid = true;  
                 }  
             }  
             catch (Exception ex)  
             {  
                 MessageBox.Show(ex.Message, "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);  
             }  
 
             return isValid;  
         }  
     }  
 }  
 

 using System.Diagnostics;  
 using System.Windows.Forms;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public partial class BingMapsApplicationIdPromptForm : Form  
     {  
         public BingMapsApplicationIdPromptForm()  
         {  
             InitializeComponent();  
         }  
 
         public string ApplicationId  
         {  
             get { return MapKeyTextBox.Text; }  
         }  
 
         private void OkButton_Click(object sender, System.EventArgs e)  
         {  
             DialogResult = DialogResult.OK;  
         }  
 
         private void LinkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)  
         {  
             Process.Start("https://www.bingmapsportal.com/");  
         }  
     }  
 }  
 

 using System;  
 using System.Drawing;  
 using System.Drawing.Drawing2D;  
 using System.Linq;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class CollapsiblePanel : Panel  
     {  
         private int lineWidth;  
         private int panelWidth;  
         private bool isCollapsible;  
         private Size collapsibleBoxSize;  
         private PictureBox collapsibleBoxPictureBox;  
 
         public event EventHandler ToggleExpandedButtonClick;  
 
         public CollapsiblePanel()  
         {  
             lineWidth = 5;  
             isCollapsible = false;  
             collapsibleBoxSize = new Size(12, 110);  
             collapsibleBoxPictureBox = new PictureBox();  
             collapsibleBoxPictureBox.Cursor = Cursors.Hand;  
             collapsibleBoxPictureBox.BackColor = Color.Transparent;  
             collapsibleBoxPictureBox.Location = new Point(Width - lineWidth - collapsibleBoxSize.Width, Height / 2 - collapsibleBoxSize.Height / 2);  
             collapsibleBoxPictureBox.Size = collapsibleBoxSize;  
             collapsibleBoxPictureBox.Click += CollapsibleBoxPictureBox_Click;  
             collapsibleBoxPictureBox.MouseEnter += CollapsibleBoxPictureBox_MouseEnter;  
             collapsibleBoxPictureBox.MouseLeave += CollapsibleBoxPictureBox_MouseLeave;  
             collapsibleBoxPictureBox.Image = GetCollapsibleImage();  
             Controls.Add(collapsibleBoxPictureBox);  
 
             Width = lineWidth + panelWidth + collapsibleBoxPictureBox.Width;  
             Resize += CollapsiblePanel_Resize;  
         }  
 
         public int LineWidth  
         {  
             get { return lineWidth; }  
             set { lineWidth = value; }  
         }  
 
         public int PanelWidth  
         {  
             get { return panelWidth; }  
             set { panelWidth = value; }  
         }  
 
         protected override void OnPaint(PaintEventArgs e)  
         {  
             base.OnPaint(e);  
 
             Rectangle drawingRectangle = new Rectangle(Width - lineWidth, 0, lineWidth, Height);  
             LinearGradientBrush myBrush = new LinearGradientBrush(drawingRectangle, Color.Gray, Color.White, LinearGradientMode.Horizontal);  
             e.Graphics.FillRectangle(myBrush, drawingRectangle);  
         }  
 
         protected void OnToggleExpandedButtonClick(EventArgs e)  
         {  
             EventHandler handler = ToggleExpandedButtonClick;  
             if (handler != null)  
             {  
                 handler(this, e);  
             }  
         }  
 
         private void CollapsiblePanel_Resize(object sender, EventArgs e)  
         {  
             collapsibleBoxPictureBox.Location = new Point(Width - lineWidth - collapsibleBoxSize.Width, Height / 2 - collapsibleBoxSize.Height / 2);  
         }  
 
         private Bitmap GetCollapsibleImage()  
         {  
             if (collapsibleBoxPictureBox.Image != null) collapsibleBoxPictureBox.Image.Dispose();  
 
             Bitmap bitmap = new Bitmap(collapsibleBoxPictureBox.Size.Width, collapsibleBoxPictureBox.Size.Height);  
             using (Graphics g = Graphics.FromImage(bitmap))  
             {  
                 Size imageSize = Resources.collapse.Size;  
                 int x = (collapsibleBoxPictureBox.Width - imageSize.Width) / 2;  
                 int y = (collapsibleBoxPictureBox.Height - imageSize.Height) / 2;  
                 g.DrawImage(isCollapsible ? Resources.expand : Resources.collapse, x, y);  
             }  
 
             return bitmap;  
         }  
 
         private void CollapsibleBoxPictureBox_Click(object sender, EventArgs e)  
         {  
             isCollapsible = !isCollapsible;  
             collapsibleBoxPictureBox.Image = GetCollapsibleImage();  
 
             foreach (var item in Controls.OfType<Control>().Where(c => c != collapsibleBoxPictureBox))  
             {  
                 item.Visible = !isCollapsible;  
             }  
 
             Width = isCollapsible ? lineWidth + collapsibleBoxSize.Width : panelWidth + lineWidth + collapsibleBoxSize.Width;  
             OnToggleExpandedButtonClick(e);  
 
             Refresh();  
         }  
 
         private void CollapsibleBoxPictureBox_MouseEnter(object sender, EventArgs e)  
         {  
             collapsibleBoxPictureBox.BackColor = Color.FromArgb(150, 4, 60, 153);  
         }  
 
         private void CollapsibleBoxPictureBox_MouseLeave(object sender, EventArgs e)  
         {  
             collapsibleBoxPictureBox.BackColor = Color.Transparent;  
         }  
     }  
 }  
 

 using System;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class OverlayChangedOverlaySwitcherEventArgs : EventArgs  
     {  
         private Overlay overlay;  
         private bool cancel;  
 
         public OverlayChangedOverlaySwitcherEventArgs()  
             : this(null)  
         { }  
 
         public OverlayChangedOverlaySwitcherEventArgs(Overlay overlay)  
         {  
             this.overlay = overlay;  
         }  
 
         public Overlay Overlay  
         {  
             get { return overlay; }  
         }  
 
         public bool Cancel  
         {  
             get { return cancel; }  
             set { cancel = value; }  
         }  
     }  
 }  
 

 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Drawing;  
 using System.Linq;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.DesktopEdition;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public partial class OverlaySwitcher : UserControl  
     {  
         public event EventHandler<OverlayChangedOverlaySwitcherEventArgs> OverlayChanged;  
 
         private WinformsMap mapControl;  
         private Collection<Overlay> overlays;  
         private Overlay checkedOverlay;  
 
         public OverlaySwitcher()  
             : this(null, null)  
         { }  
 
         public OverlaySwitcher(IEnumerable<Overlay> overlays, WinformsMap map)  
         {  
             InitializeComponent();  
 
             this.mapControl = map;  
             this.overlays = new Collection<Overlay>();  
             if (overlays != null)  
             {  
                 foreach (var overlay in overlays)  
                 {  
                     this.overlays.Add(overlay);  
                 }  
             }  
 
             LoadUIs();  
         }  
 
         public WinformsMap MapControl  
         {  
             get { return mapControl; }  
             set { mapControl = value; }  
         }  
 
         public Collection<Overlay> Overlays  
         {  
             get { return overlays; }  
         }  
 
         public void LoadUIs()  
         {  
             if (mapControl == null && overlays.Count == 0) return;  
 
             int index = 0;  
             int width = 0;  
             int height = 0;  
             foreach (var item in Overlays)  
             {  
                 RadioButton radioButton = new RadioButton();  
                 radioButton.UseVisualStyleBackColor = true;  
                 radioButton.AutoSize = true;  
                 radioButton.TextAlign = ContentAlignment.MiddleLeft;  
                 radioButton.Tag = item;  
                 radioButton.Text = item.Name;  
                 radioButton.Checked = item.IsVisible;  
                 radioButton.CheckedChanged += RadioButton_CheckedChanged;  
                 height = 5 + index * 20;  
                 radioButton.Location = new Point(15, height);  
                 if (width < radioButton.Width) width = radioButton.Width + 80;  
                 height += radioButton.Height + 10;  
                 Controls.Add(radioButton);  
                 index++;  
             }  
             Width = width;  
             Height = height;  
 
             Refresh();  
         }  
 
         private void RadioButton_CheckedChanged(object sender, EventArgs e)  
         {  
             RadioButton radioButton = (RadioButton)sender;  
             if (radioButton.Checked)  
             {  
                 Overlay currentOverlay = (Overlay)radioButton.Tag;  
                 var overlaySwitchedEventArgs = new OverlayChangedOverlaySwitcherEventArgs((Overlay)radioButton.Tag);  
                 OnOverlayChanged(overlaySwitchedEventArgs);  
                 if (overlaySwitchedEventArgs.Cancel)  
                 {  
                     radioButton.Checked = false;  
                     if (checkedOverlay == null)  
                     {  
                         foreach (RadioButton item in Controls.OfType<RadioButton>())  
                         {  
                             Overlay tempOverlay = item.Tag as Overlay;  
                             if (tempOverlay != null && tempOverlay.IsVisible)  
                             {  
                                 item.Checked = true;  
                                 break;  
                             }  
                         }  
                     }  
                     else  
                     {  
                         foreach (RadioButton item in Controls.OfType<RadioButton>().Where(item => item.Tag == checkedOverlay))  
                         {  
                             item.Checked = true;  
                             break;  
                         }  
                     }  
                 }  
                 else  
                 {  
                     checkedOverlay = currentOverlay;  
                     foreach (var overlay in Overlays)  
                     {  
                         overlay.IsVisible = checkedOverlay == overlay;  
                     }  
                     mapControl.Refresh();  
                 }  
             }  
         }  
 
         protected virtual void OnOverlayChanged(OverlayChangedOverlaySwitcherEventArgs e)  
         {  
             EventHandler<OverlayChangedOverlaySwitcherEventArgs> handler = OverlayChanged;  
             if (handler != null)  
             {  
                 handler(this, e);  
             }  
         }  
     }  
 }