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.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 Bitmap bitmap;  
         private MapModel mapModel;  
         private LayerSwitcher switcher;  
         private AreaCreateMode createAreasMode;  
         private Collection<QueryResultItem> queryResult;  
 
         public MainForm()  
         {  
             InitializeComponent();  
             InitializeBackground();  
         }  
 
         private void MainForm_Load(object sender, EventArgs e)  
         {  
             InitializeMapModel();  
             InitializeLayerSwitcher();  
 
             mapPicture.MouseMove += Map_MouseMove;  
             bitmap = new Bitmap(mapPicture.Width, mapPicture.Height);  
             foreach (var name in mapModel.GetCandidatePoiLayers().Select(l => l.Name))  
             {  
                 CandidatePoiLayersComboBox.Items.Add(name);  
             }  
             CandidatePoiLayersComboBox.SelectedIndex = 2;  
 
             RouteRadioButton.Checked = true;  
             PanRadioButton.Checked = true;  
             DistanceUnitComboBox.SelectedIndex = 1;  
             DistanceValueTextBox.Text = "2";  
             isLoad = true;  
 
             UpdateQueryResult();  
         }  
 
         private void CandidatePoiLayersComboBox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             mapModel.QueryingFeatureLayer = mapModel.GetPoiFeatureLayerByName(CandidatePoiLayersComboBox.SelectedItem.ToString());  
             UpdatePioTypeCandidates();  
         }  
 
         private void CandidatePoiTypeComboBox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             UpdateQueryResult();  
         }  
 
         private void DistanceUnitComboBox_SelectedIndexChanged(object sender, EventArgs e)  
         {  
             UpdateUnitSystem(DistanceUnitComboBox.SelectedIndex == 1 ? UnitSystem.NauticalMile : UnitSystem.Metric);  
         }  
 
         private void AreaTypeRadioButton_CheckedChanged(object sender, EventArgs e)  
         {  
             BufferPanel.Visible = false;  
             RoutePanel.Visible = false;  
 
             // Switch area create mode.  
             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 ControlMapMode_CheckedChanged(object sender, EventArgs e)  
         {  
             mapModel.TrackMode = DrawPointRadioButton.Checked ? TrackMode.Point : TrackMode.None;  
 
             RadioButton radioButton = (RadioButton)sender;  
             radioButton.FlatAppearance.BorderColor = radioButton.Checked ? Color.FromArgb(136, 136, 136) : Color.White;  
         }  
 
         private void LeftSideBarPanel_PanelCollapseButtonClick(object sender, EventArgs e)  
         {  
             mapPicture.Width = Width - leftSideBarPanel.Width - 15;  
             mapPicture.Left = leftSideBarPanel.Width;  
             RefreshMap();  
         }  
 
         private void DistanceValueTextBox_KeyPress(object sender, KeyPressEventArgs e)  
         {  
             // Accept input number and dot only. Otherwise, handle it.  
             int kc = e.KeyChar;  
             if ((kc < 48 || kc > 57) && kc != 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 RouteTimeTextBox_KeyPress(object sender, KeyPressEventArgs e)  
         {  
             int kc = e.KeyChar;  
 
             // If input "DEL", and the new value is not a number, handle it.  
             if (kc == 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, out value);  
                     if (!isNewValueDouble)  
                     {  
                         e.Handled = isOldValueDouble;  
                     }  
                 }  
             }  
             else if ((kc < 48 || kc > 57) && kc != 8)  
             {  
                 e.Handled = true;  
             }  
         }  
 
         private void QueryResultItems_CellClick(object sender, DataGridViewCellEventArgs e)  
         {  
             if (e.ColumnIndex == 0)  
             {  
                 // Zoom to specific feature.  
                 DataGridViewCell cell = QueryResultItemsDataGridView.Rows[e.RowIndex].Cells["cluLocation"];  
                 if (cell.Value != null)  
                 {  
                     PointShape pointShape = new PointShape(cell.Value.ToString());  
                     mapModel.MapEngine.CurrentExtent = pointShape.Buffer(200, GeographyUnit.Meter, DistanceUnit.Meter).GetBoundingBox();  
                     RefreshMap();  
                 }  
             }  
         }  
 
         private void QueryResultItems_CellMouseEnter(object sender, DataGridViewCellEventArgs e)  
         {  
             // Highlight cell when mouse enter.  
             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 QueryResultItems_CellMouseLeave(object sender, DataGridViewCellEventArgs e)  
         {  
             // Restore the background when mouse leave the cell.  
             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 ApplyButton_Click(object sender, EventArgs e)  
         {  
             UpdateQueryResult();  
         }  
 
         private void ClearRadioButton_Click(object sender, EventArgs e)  
         {  
             rbtnClear.Checked = false;  
             PanRadioButton.Checked = true;  
             QueryResultItemsDataGridView.Visible = false;  
 
             mapModel.ServiceAreaLayer.InternalFeatures.Clear();  
             mapModel.TrackLayer.InternalFeatures.Clear();  
             mapModel.AddMarkersByFeatures(null);  
             RefreshMap();  
         }  
 
         private void ToggleLayerSwitcherPictureBox_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 Map_MouseMove(object sender, MouseEventArgs e)  
         {  
             PointShape mouseLocation = ExtentHelper.ToWorldCoordinate(mapModel.CurrentExtent, new ScreenPointF(e.X, e.Y), mapPicture.Width, mapPicture.Height);  
             FooterLocationXLabel.Text = string.Format(CultureInfo.InvariantCulture, "X:{0:0.##}", mouseLocation.X);  
             FooterLocationYLabel.Text = string.Format(CultureInfo.InvariantCulture, "Y:{0:0.##}", mouseLocation.Y);  
         }  
 
         private static void LayerSwitcher_LayerChanging(object sender, LayerChangingLayerSwitcherEventArgs e)  
         {  
             BingMapsLayer bingMapsLayer = e.Layer as BingMapsLayer;  
             if (bingMapsLayer != null)  
             {  
                 string applicationId = MapSuiteSampleHelper.GetBingMapsApplicationId();  
                 if (!string.IsNullOrEmpty(applicationId)) bingMapsLayer.ApplicationId = applicationId;  
                 else e.Cancel = true;  
             }  
         }  
 
         private void LayerSwitcher_LayerChanged(object sender, LayerChangedLayerSwitcherEventArgs e)  
         {  
             RefreshMap();  
         }  
 
         private void MapControl_Click(object sender, MouseEventArgs e)  
         {  
             if (mapModel.TrackMode == TrackMode.Point)  
             {  
                 PointShape mouseLocation = ExtentHelper.ToWorldCoordinate(mapModel.MapEngine.CurrentExtent, new ScreenPointF(e.X, e.Y), mapPicture.Width, mapPicture.Height);  
                 mapModel.TrackLayer.InternalFeatures.Clear();  
                 mapModel.TrackLayer.InternalFeatures.Add(new Feature(mouseLocation));  
 
                 BaseShape tempRestrictionShape = mapModel.GetRestrictionShape();  
                 if (mapModel.QueryingFeatureLayer != null && tempRestrictionShape != null && mouseLocation.IsWithin(tempRestrictionShape))  
                 {  
                     mapModel.PlottedPoint = mouseLocation;  
                     UpdateQueryResult();  
                 }  
                 else  
                 {  
                     MessageBox.Show(Resources.SearchOutOfBoundaryMessage, "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information);  
                 }  
 
                 RefreshMap();  
             }  
         }  
 
         private void ToolBar_ButtonClick(object sender, ToolBarButtonClickEventArgs e)  
         {  
             switch (e.Button.Tag.ToString())  
             {  
                 case "Zoom In":  
                     mapModel.CurrentExtent.ScaleDown(50);  
                     break;  
                 case "Zoom Out":  
                     mapModel.CurrentExtent.ScaleUp(50);  
                     break;  
                 case "Full Extent":  
                     mapModel.CurrentExtent = ExtentHelper.GetDrawingExtent(MapModel.DefaultExtent, bitmap.Width, bitmap.Height);  
                     break;  
                 case "Pan Left":  
                     mapModel.CurrentExtent = ExtentHelper.Pan(mapModel.CurrentExtent, PanDirection.Left, 20);  
                     break;  
                 case "Pan Right":  
                     mapModel.CurrentExtent = ExtentHelper.Pan(mapModel.CurrentExtent, PanDirection.Right, 20);  
                     break;  
                 case "Pan Up":  
                     mapModel.CurrentExtent = ExtentHelper.Pan(mapModel.CurrentExtent, PanDirection.Up, 20);  
                     break;  
                 case "Pan Down":  
                     mapModel.CurrentExtent = ExtentHelper.Pan(mapModel.CurrentExtent, PanDirection.Down, 20);  
                     break;  
             }  
 
             RefreshMap();  
         }  
 
         private void InitializeMapModel()  
         {  
             queryResult = new Collection<QueryResultItem>();  
             mapModel = new MapModel();  
             mapModel.MapEngine.CurrentExtent = ExtentHelper.GetDrawingExtent(new RectangleShape(-10782584.5066971, 3916291.54400321, -10769504.2529497, 3907774.56943023), mapPicture.Width, mapPicture.Height);  
             mapModel.TrackLayer.InternalFeatures.Add(new Feature(thinkGeoLocation));  
             mapModel.PlottedPoint = thinkGeoLocation;  
             mapModel.PlottedPointChanged += (s, e) => UpdateQueryResult(e.PlottedPoint);  
         }  
 
         private void InitializeLayerSwitcher()  
         {  
             switcher = new LayerSwitcher(mapModel);  
             switcher.Anchor = AnchorStyles.Right | AnchorStyles.Top;  
             switcher.Location = new Point(Width - 208, 85);  
             switcher.Size = new Size(185, 90);  
             switcher.LayerChanging += LayerSwitcher_LayerChanging;  
             switcher.LayerChanged += LayerSwitcher_LayerChanged;  
             Controls.Add(switcher);  
             switcher.BringToFront();  
 
             PictureBox overlaySwitcherButton = new PictureBox();  
             overlaySwitcherButton.Anchor = AnchorStyles.Right | AnchorStyles.Top;  
             overlaySwitcherButton.Image = Resources.switcher_minimize;  
             overlaySwitcherButton.SizeMode = PictureBoxSizeMode.AutoSize;  
             overlaySwitcherButton.Location = new Point(switcher.Location.X + switcher.Width - overlaySwitcherButton.Width - 8, switcher.Location.Y + 5);  
             overlaySwitcherButton.Click += ToggleLayerSwitcherPictureBox_Click;  
             Controls.Add(overlaySwitcherButton);  
             overlaySwitcherButton.BringToFront();  
             switcher.Refresh();  
         }  
 
         private void InitializeBackground()  
         {  
             BuildingTypePanel.RedrawBackground(g =>  
             {  
                 Rectangle rect = new Rectangle(0, 0, BuildingTypePanel.Width - 1, BuildingTypePanel.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 g.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             });  
 
             ControlModePanel.RedrawBackground(g =>  
             {  
                 Rectangle rect = new Rectangle(0, 0, ControlModePanel.Width - 1, ControlModePanel.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 g.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             });  
 
             AreaTypePanel.RedrawBackground(g =>  
             {  
                 Rectangle rect = new Rectangle(0, 0, AreaTypePanel.Width - 1, AreaTypePanel.Height - 1);  
                 GraphicsPath path = MapSuiteSampleHelper.CreateRoundPath(rect, 10);  
                 g.DrawPath(new Pen(Color.FromArgb(255, 200, 200, 200), 1), path);  
             });  
         }  
 
         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(PointShape plottedPoint)  
         {  
             mapModel.PlottedPoint = plottedPoint;  
             UpdateQueryResult();  
         }  
 
         // Query service area by the PlottedPoint.  
         // Update the UIs by the queried result.  
         private void UpdateQueryResult()  
         {  
             if (mapModel.PlottedPoint == null || !isLoad) return;  
 
             mapModel.ServiceAreaLayer.Open();  
             mapModel.QueryingFeatureLayer.Open();  
 
             Dictionary<string, object> parameters = GetServiceAreaAnalysisParameters();  
             ServiceAreaAnalysis serviceAreaAnalysis = MapSuiteSampleHelper.GetAreaAnalysis(createAreasMode);  
             Feature serviceAreaResult = serviceAreaAnalysis.CreateServiceAreaFeature(mapModel.PlottedPoint, mapModel.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.CurrentExtent = mapModel.ServiceAreaLayer.GetBoundingBox();  
                 RefreshMap();  
             }  
         }  
 
         private Collection<Feature> GetQueryResultFeatures()  
         {  
             Collection<Feature> queryResultFeatures = new Collection<Feature>();  
             if (mapModel.ServiceAreaLayer.InternalFeatures.Count == 0) return queryResultFeatures;  
 
             // Get the predefined service area.  
             BaseShape serviceAreaShape = mapModel.ServiceAreaLayer.InternalFeatures[0].GetShape();  
 
             // Query the features by the service area.  
             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;  
         }  
 
         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(txtRouteTime.Text, out driveTimeInMinutes))  
                     {  
                         parameters[Resources.DriveTimeInMinutesKey] = driveTimeInMinutes;  
                     }  
                     break;  
             }  
             return parameters;  
         }  
 
         private void RefreshMap()  
         {  
             if (mapModel.MapEngine.StaticLayers.Count > 0 && mapPicture.Width > 0)  
             {  
                 mapModel.MapEngine.OpenAllLayers();  
 
                 bitmap = new Bitmap(mapPicture.Width, mapPicture.Height);  
                 mapPicture.CreateGraphics().CompositingMode = CompositingMode.SourceCopy;  
 
                 mapModel.MapEngine.CurrentExtent = ExtentHelper.GetDrawingExtent(mapModel.MapEngine.CurrentExtent, mapPicture.Width, mapPicture.Height);  
                 mapModel.MapEngine.DrawStaticLayers(bitmap, mapModel.MapUnit);  
                 mapModel.MapEngine.DrawDynamicLayers(bitmap, mapModel.MapUnit);  
                 mapModel.MapEngine.DrawAdornmentLayers(bitmap, mapModel.MapUnit);  
                 mapModel.MapEngine.CloseAllLayers();  
 
                 UpdateImageSource();  
                 mapPicture.Refresh();  
             }  
         }  
 
         private void UpdateImageSource()  
         {  
             Image oldImage = mapPicture.Image;  
             mapPicture.Image = bitmap;  
             if (oldImage != null) oldImage.Dispose();  
         }  
 
         private void UpdateUnitSystem(UnitSystem unitSystem)  
         {  
             ScaleBarAdornmentLayer adornmentLayer = mapModel.MapEngine.AdornmentLayers[Resources.ScaleBarLayerKey] as ScaleBarAdornmentLayer;  
             if (adornmentLayer != null)  
             {  
                 adornmentLayer.UnitFamily = unitSystem;  
                 RefreshMap();  
             }  
         }  
     }  
 }  
 

 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 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);  
     }  
 }  
 

 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 drivingTimeInMinutes = 6;  
             string streetShapePathFilename = (string)parameters[Resources.StreetShapePathFilenameKey];  
             if (parameters.ContainsKey(Resources.DriveTimeInMinutesKey)) drivingTimeInMinutes = (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);  
 
             featureSource.Open();  
             ManagedProj4Projection projection = new ManagedProj4Projection();  
             projection.InternalProjectionParametersString = ManagedProj4Projection.GetBingMapParametersString();  
             projection.ExternalProjectionParametersString = ManagedProj4Projection.GetEpsgParametersString(4326);  
 
             projection.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, drivingTimeInMinutes, 0), 100, GeographyUnit.Feet);  
             polygonShape = (PolygonShape)projection.ConvertToInternalProjection(polygonShape);  
             projection.Close();  
 
             return polygonShape;  
         }  
     }  
 }  
 

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

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

 using System;  
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Configuration;  
 using System.IO;  
 using System.Linq;  
 using System.Windows.Forms;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.SiteSelection.Properties;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     public class MapModel  
     {  
         public static RectangleShape DefaultExtent = new RectangleShape(-10782584.5066971, 3916291.54400321, -10769504.2529497, 3907774.56943023);  
 
         private TrackMode trackMode;  
         private GeographyUnit mapUnit;  
         private MapEngine mapEngine;  
         private PointShape plottedPoint;  
         private BaseShape restrictionShape;  
         private ShapeFileFeatureLayer currentQueryLayer;  
         private ObservableCollection<ShapeFileFeatureLayer> poiFeatureLayers;  
         private Collection<Layer> baseLayers;  
 
         public event EventHandler<PlottedPointChangedMapModelEventArgs> PlottedPointChanged;  
 
         public MapModel()  
         {  
             mapUnit = GeographyUnit.Meter;  
             trackMode = TrackMode.None;  
             baseLayers = new Collection<Layer>();  
             mapEngine = new MapEngine();  
             mapEngine.ShowLogo = false;  
             mapEngine.CurrentExtent = DefaultExtent;  
             InitializeLayers();  
         }  
 
         public TrackMode TrackMode  
         {  
             get { return trackMode; }  
             set { trackMode = value; }  
         }  
 
         public GeographyUnit MapUnit  
         {  
             get { return mapUnit; }  
             set { mapUnit = value; }  
         }  
 
         public MapEngine MapEngine  
         {  
             get { return mapEngine; }  
             set { mapEngine = value; }  
         }  
 
         public Collection<Layer> BaseLayers  
         {  
             get { return baseLayers; }  
         }  
 
         public PointShape PlottedPoint  
         {  
             get { return plottedPoint; }  
             set { plottedPoint = value; }  
         }  
 
         public RectangleShape CurrentExtent  
         {  
             get { return mapEngine.CurrentExtent; }  
             set { mapEngine.CurrentExtent = value; }  
         }  
 
         public ShapeFileFeatureLayer QueryingFeatureLayer  
         {  
             get { return currentQueryLayer; }  
             set { currentQueryLayer = value; }  
         }  
 
         public GeoCollection<Layer> StaticLayers  
         {  
             get { return mapEngine.StaticLayers; }  
         }  
 
         public ShapeFileFeatureLayer HotelsLayer  
         {  
             get { return (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.HotelsLayerKey]; }  
         }  
 
         public ShapeFileFeatureLayer MedicalFacilitesLayer  
         {  
             get { return (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.MedicalFacilitesLayerKey]; }  
         }  
 
         public ShapeFileFeatureLayer PublicFacilitesLayer  
         {  
             get { return (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.PublicFacilitesLayerKey]; }  
         }  
 
         public ShapeFileFeatureLayer RestaurantsLayer  
         {  
             get { return (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.RestaurantsLayerKey]; }  
         }  
 
         public ShapeFileFeatureLayer SchoolsLayer  
         {  
             get { return (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.SchoolsLayerKey]; }  
         }  
 
         public InMemoryFeatureLayer ServiceAreaLayer  
         {  
             get { return (InMemoryFeatureLayer)mapEngine.DynamicLayers[Resources.ServiceAreaLayerKey]; }  
         }  
 
         public InMemoryFeatureLayer TrackLayer  
         {  
             get { return (InMemoryFeatureLayer)mapEngine.DynamicLayers[Resources.TrackLayer]; }  
         }  
 
         public void AddMarkersByFeatures(IEnumerable<Feature> features)  
         {  
             InMemoryFeatureLayer markerLayer = (InMemoryFeatureLayer)mapEngine.DynamicLayers[Resources.MakerOverlayKey];  
             InMemoryFeatureLayer centerPointLayer = (InMemoryFeatureLayer)mapEngine.DynamicLayers[Resources.TrackLayer];  
 
             Style markerStyle = markerLayer.ZoomLevelSet.ZoomLevel01.CustomStyles[0];  
             markerLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Clear();  
             markerLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(markerStyle);  
             markerLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(QueryingFeatureLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle);  
 
             markerLayer.Open();  
             centerPointLayer.Open();  
 
             markerLayer.Clear();  
             centerPointLayer.Clear();  
 
             if (plottedPoint != null)  
             {  
                 centerPointLayer.InternalFeatures.Add(new Feature(plottedPoint));  
             }  
 
             if (features != null)  
             {  
                 foreach (Feature feature in features)  
                 {  
                     markerLayer.InternalFeatures.Add(feature);  
                 }  
             }  
         }  
 
         public ShapeFileFeatureLayer GetPoiFeatureLayerByName(string layerName)  
         {  
             return poiFeatureLayers.FirstOrDefault(l => l.Name.Equals(layerName, StringComparison.OrdinalIgnoreCase));  
         }  
 
         public ObservableCollection<ShapeFileFeatureLayer> GetCandidatePoiLayers()  
         {  
             return poiFeatureLayers ?? (poiFeatureLayers = 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 InitializeLayers()  
         {  
             // Initialize base layers.  
             string cacheFolder = Path.Combine(Path.GetTempPath(), "TileCache");  
             WorldMapKitLayer worldMapKitLayer = new WorldMapKitLayer();  
             worldMapKitLayer.Name = Resources.WorldMapKitOverlayName;  
             worldMapKitLayer.Projection = WorldMapKitProjection.SphericalMercator;  
             baseLayers.Add(worldMapKitLayer);  
             worldMapKitLayer.IsVisible = true;  
             worldMapKitLayer.TileCache = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitOverlayName);  
             mapEngine.StaticLayers.Add(Resources.WorldMapKitOverlayName, worldMapKitLayer);  
 
             OpenStreetMapLayer openStreetMapLayer = new OpenStreetMapLayer();  
             openStreetMapLayer.Name = Resources.OSMOverlayName;  
             baseLayers.Add(openStreetMapLayer);  
             openStreetMapLayer.IsVisible = false;  
             openStreetMapLayer.TileCache = new FileBitmapTileCache(cacheFolder, Resources.OSMOverlayName);  
 
             BingMapsLayer bingMapsAerialLayer = new BingMapsLayer();  
             bingMapsAerialLayer.Name = Resources.BingMapsAerialOverlayName;  
             bingMapsAerialLayer.MapType = BingMapsMapType.Aerial;  
             baseLayers.Add(bingMapsAerialLayer);  
             bingMapsAerialLayer.IsVisible = false;  
             bingMapsAerialLayer.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsAerialOverlayName);  
 
             BingMapsLayer bingMapsRoadLayer = new BingMapsLayer();  
             bingMapsRoadLayer.Name = Resources.BingMapsRoadOverlayName;  
             bingMapsRoadLayer.MapType = BingMapsMapType.Road;  
             baseLayers.Add(bingMapsRoadLayer);  
             bingMapsRoadLayer.IsVisible = false;  
             bingMapsRoadLayer.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsRoadOverlayName);  
 
             // Initialize feature layers  
             Proj4Projection proj4 = new Proj4Projection();  
             proj4.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();  
             proj4.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();  
             proj4.Open();  
 
             ShapeFileFeatureLayer restrictedLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestrictedShapeFilePathName"]);  
             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 } });  
             restrictedLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = extentStyle;  
             restrictedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restrictedLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.RestrictedLayerKey, restrictedLayer);  
 
             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;  
             mapEngine.DynamicLayers.Add(Resources.ServiceAreaLayerKey, serviceAreaLayer);  
 
             InMemoryFeatureLayer trackFeatureLayer = new InMemoryFeatureLayer();  
             trackFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\drawPoint.png"));  
             trackFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             mapEngine.DynamicLayers.Add(Resources.TrackLayer, trackFeatureLayer);  
 
             ShapeFileFeatureLayer hotelsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["HotelsShapeFilePathName"]);  
             hotelsLayer.Name = Resources.HotelsLayerKey;  
             hotelsLayer.Transparency = 100f;  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\Hotel.png"));  
             hotelsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             hotelsLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.HotelsLayerKey, hotelsLayer);  
 
             ShapeFileFeatureLayer medicalFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["MedicalFacilitiesShapeFilePathName"]);  
             medicalFacilitesLayer.Name = Resources.MedicalFacilitesLayerKey;  
             medicalFacilitesLayer.Transparency = 100f;  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\DrugStore.png"));  
             medicalFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             medicalFacilitesLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.MedicalFacilitesLayerKey, medicalFacilitesLayer);  
 
             ShapeFileFeatureLayer publicFacilitesLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["PublicFacilitiesShapeFilePathName"]);  
             publicFacilitesLayer.Name = Resources.PublicFacilitesLayerKey;  
             publicFacilitesLayer.Transparency = 100f;  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\public_facility.png"));  
             publicFacilitesLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             publicFacilitesLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.PublicFacilitesLayerKey, publicFacilitesLayer);  
 
             ShapeFileFeatureLayer restaurantsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["RestaurantsShapeFilePathName"]);  
             restaurantsLayer.Name = Resources.RestaurantsLayerKey;  
             restaurantsLayer.Transparency = 100f;  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\restaurant.png"));  
             restaurantsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restaurantsLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.RestaurantsLayerKey, restaurantsLayer);  
 
             ShapeFileFeatureLayer schoolsLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["SchoolsShapeFilePathName"]);  
             schoolsLayer.Name = Resources.SchoolsLayerKey;  
             schoolsLayer.Transparency = 100f;  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle = new PointStyle(new GeoImage(@"..\..\Image\school.png"));  
             schoolsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             schoolsLayer.FeatureSource.Projection = proj4;  
             mapEngine.DynamicLayers.Add(Resources.SchoolsLayerKey, schoolsLayer);  
 
             // Initialize marker layer.  
             InMemoryFeatureLayer markerLayer = new InMemoryFeatureLayer();  
             markerLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(new PointStyle(new GeoImage(@"..\..\Image\selectedHalo.png")));  
             markerLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             mapEngine.DynamicLayers.Add(Resources.MakerOverlayKey, markerLayer);  
 
             // Initialize adornments.  
             LegendAdornmentLayer legendlayer = new LegendAdornmentLayer();  
             legendlayer.Height = 135;  
             legendlayer.Location = AdornmentLocation.LowerRight;  
             mapEngine.AdornmentLayers.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;  
             mapEngine.AdornmentLayers.Add(Resources.ScaleBarLayerKey, scaleBar);  
         }  
 
         public BaseShape GetRestrictionShape()  
         {  
             if (restrictionShape == null)  
             {  
                 ShapeFileFeatureLayer restictionLayer = (ShapeFileFeatureLayer)mapEngine.DynamicLayers[Resources.RestrictedLayerKey];  
 
                 restictionLayer.Open();  
                 Feature firstFeature = restictionLayer.QueryTools.GetFeatureById("1", ReturningColumnsType.NoColumns);  
                 restrictionShape = firstFeature.GetShape();  
             }  
 
             return restrictionShape;  
         }  
 
         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);  
         }  
     }  
 }  
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     [Serializable]  
     public class PlottedPointChangedMapModelEventArgs : EventArgs  
     {  
         private PointShape plottedPoint;  
 
         public PlottedPointChangedMapModelEventArgs()  
             : this(null)  
         { }  
 
         public PlottedPointChangedMapModelEventArgs(PointShape plottedPoint)  
         {  
             this.plottedPoint = plottedPoint;  
         }  
 
         public PointShape PlottedPoint  
         {  
             get { return plottedPoint; }  
         }  
     }  
 }  
 

 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 DataGridViewTextBoxCell textCell;  
         private DataGridViewTextBoxCell locationCell;  
         private DataGridViewImageCell imageButtonCell;  
 
         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 = null;  
             switch (createAreaMode)  
             {  
                 case AreaCreateMode.Route:  
                     serviceAreaAnalysis = new RouteAccessibleAreaAnalysis();  
                     break;  
 
                 default:  
                     serviceAreaAnalysis = new BufferServiceAreaAnalysis();  
                     break;  
             }  
 
             return serviceAreaAnalysis;  
         }  
 
         public static string GetBingMapsApplicationId()  
         {  
             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))  
                 {  
                     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;  
         }  
 
         public static void RedrawBackground(this Control control, Action<Graphics> drawAction, SmoothingMode smoothingMode = SmoothingMode.HighQuality)  
         {  
             Bitmap newBackground = new Bitmap(control.Width, control.Height);  
             using (Graphics g = Graphics.FromImage(newBackground))  
             {  
                 g.SmoothingMode = smoothingMode;  
                 if (drawAction != null) drawAction(g);  
             }  
 
             if (control.BackgroundImage != null) control.BackgroundImage.Dispose();  
             control.BackgroundImage = newBackground;  
         }  
 
         private static bool IsBingMapsKeyValid(string bingMapsKey)  
         {  
             bool isValid = false;  
 
             try  
             {  
                 string loginServiceUri = String.Format(CultureInfo.InvariantCulture  
                               , bingLoginServiceTemplate, BingMapsMapType.Road, 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;  
 
 namespace ThinkGeo.MapSuite.SiteSelection  
 {  
     [Serializable]  
     public enum TrackMode  
     {  
         None = 0,  
         Point = 1  
     }  
 }