Source Code iOSEditionSample GeometricFunctions.zip
AppDelegate.cs
using Foundation;
using UIKit;
namespace GeometricFunctions
{
// The UIApplicationDelegate for the application. This class is responsible for launching the
// User Interface of the application, as well as listening (and optionally responding) to
// application events from iOS.
[Register("AppDelegate")]
public partial class AppDelegate : UIApplicationDelegate
{
// class-level declarations
public override UIWindow Window
{
get;
set;
}
// This method is invoked when the application is about to move from active to inactive state.
// OpenGL applications should use this method to pause.
public override void OnResignActivation(UIApplication application)
{
}
// This method should be used to release shared resources and it should store the application state.
// If your application supports background exection this method is called instead of WillTerminate
// when the user quits.
public override void DidEnterBackground(UIApplication application)
{
}
// This method is called as part of the transiton from background to active state.
public override void WillEnterForeground(UIApplication application)
{
}
// This method is called when the application is about to terminate. Save data, if needed.
public override void WillTerminate(UIApplication application)
{
}
}
}
Main.cs
using UIKit;
namespace GeometricFunctions
{
public class Application
{
// This is the main entry point of the application.
static void Main(string[] args)
{
// if you want to use a different Application Delegate class from "AppDelegate"
// you can specify it here.
UIApplication.Main(args, null, "AppDelegate");
}
}
}
MainViewController.cs
using MonoTouch.Dialog;
using UIKit;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;
using ThinkGeo.MapSuite.Core;
namespace GeometricFunctions
{
public partial class MainViewController : UIViewController
{
private SliderViewController navigation;
public MainViewController(IntPtr handle)
: base(handle)
{ }
public override void ViewDidLoad()
{
base.ViewDidLoad();
navigation = new SliderViewController();
navigation.Position = FlyOutPosition.Left;
navigation.View.Frame = UIScreen.MainScreen.Bounds;
View.AddSubview(navigation.View);
AddChildViewController(navigation);
XDocument xDoc = XDocument.Load("AppData/GeometricFunctions.xml");
Section section = new Section("Style List");
if (xDoc.Root != null)
{
Collection<UIViewController> styleList = new Collection<UIViewController>();
Assembly currentAssembly = Assembly.GetExecutingAssembly();
foreach (var element in xDoc.Root.Elements())
{
string name = element.Attribute("Name").Value;
string image = element.Attribute("Image").Value;
string className = element.Attribute("Class").Value;
UIImage icon = UIImage.FromBundle(image);
BadgeElement iconItem = new BadgeElement(icon, name);
section.Add(iconItem);
Type sampleType = currentAssembly.GetType("GeometricFunctions." + className);
DetailViewController rootController = (DetailViewController)Activator.CreateInstance(sampleType);
XElement geometrySourceElement = element.Element("GeometrySource");
foreach (var featureWktElement in geometrySourceElement.Elements())
{
if (!string.IsNullOrEmpty(featureWktElement.Value))
{
rootController.GeometrySource.Add(new Feature(featureWktElement.Value));
}
}
rootController.DetailButtonClick = navigation.ToggleMenu;
rootController.Title = name;
UINavigationController mainController = new UINavigationController(rootController);
styleList.Add(mainController);
}
navigation.ViewControllers = styleList.ToArray();
}
navigation.NavigationRoot = new RootElement("Style List") { section };
}
}
}
MainViewController.designer.cs
// WARNING
//
// This file has been generated automatically by Xamarin Studio from the outlets and
// actions declared in your storyboard file.
// Manual changes to this file will not be maintained.
//
using System;
using Foundation;
using UIKit;
using System.CodeDom.Compiler;
namespace GeometricFunctions
{
[Register|("MainViewController")]
partial class MainViewController
{
void ReleaseDesignerOutlets ()
{
}
}
}
BufferViewController.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class BufferViewController : DetailViewController
{
private int bufferSize;
public BufferViewController()
{ }
protected override void InitializeMap()
{
bufferSize = 0;
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer bufferedLayer = new InMemoryFeatureLayer();
bufferedLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(140, 255, 155, 13)));
bufferedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("BufferedLayer", bufferedLayer);
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
InMemoryFeatureLayer bufferedLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BufferedLayer"];
bufferSize += 15;
Feature bufferSourceFeature = sourceLayer.InternalFeatures[0].CloneDeep();
Feature bufferedFeature = bufferSourceFeature.Buffer(bufferSize, 8, BufferCapType.Butt, GeographyUnit.Meter, DistanceUnit.Meter);
bufferedLayer.InternalFeatures.Clear();
bufferedLayer.InternalFeatures.Add(bufferedFeature);
layerOverlay.Refresh();
}
}
}
CenterPointViewController.cs
using System.Globalization;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class CenterPointViewController : DetailViewController
{
private ManagedProj4Projection projection;
public CenterPointViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();
mapExtent.ScaleUp(20);
MapView.CurrentExtent = mapExtent;
projection = new ManagedProj4Projection();
projection.InternalProjectionParametersString = ManagedProj4Projection.GetSphericalMercatorParametersString();
projection.ExternalProjectionParametersString = ManagedProj4Projection.GetLatLongParametersString();
projection.Open();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();
pointLayer.Open();
pointLayer.Columns.Add(new FeatureSourceColumn("Type"));
pointLayer.Close();
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSize = 12;
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, 255, 155, 13), 2);
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSolidBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 255, 248, 172));
pointLayer.DrawingMarginPercentage = 100;
TextStyle textStyle = new TextStyle();
textStyle.TextColumnName = "Type";
textStyle.Font = new GeoFont("Arial", 15);
textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;
textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;
textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);
textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);
textStyle.PointPlacement = PointPlacement.LowerCenter;
textStyle.YOffsetInPixel = -8;
pointLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("PointLayer", pointLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer pointLayer = (InMemoryFeatureLayer)layerOverlay.Layers["PointLayer"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
pointLayer.Clear();
Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();
Feature centerFeature = new Feature(feature.GetBoundingBox().GetCenterPoint());
PointShape centerPoint = (PointShape)projection.ConvertToExternalProjection(centerFeature.CloneDeep()).GetShape();
centerFeature.ColumnValues["Type"] = string.Format(CultureInfo.InvariantCulture, "Center at Lon: {0:N4}, Lat: {1:N4}", centerPoint.X, centerPoint.Y);
pointLayer.InternalFeatures.Add(centerFeature);
Feature centroidFeature = new Feature(feature.GetShape().GetCenterPoint());
PointShape centroidPoint = (PointShape)projection.ConvertToExternalProjection(centroidFeature.CloneDeep()).GetShape();
centroidFeature.ColumnValues["Type"] = string.Format(CultureInfo.InvariantCulture, "Centroid at Lon: {0:N4}, Lat: {1:N4}", centroidPoint.X, centroidPoint.Y);
pointLayer.InternalFeatures.Add(centroidFeature);
layerOverlay.Refresh();
}
}
}
ClipViewController.cs
using System.Collections.ObjectModel;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class ClipViewController : DetailViewController
{
public ClipViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 1;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
foreach (Feature feature in GeometrySource.Skip(1))
{
sourceLayer.InternalFeatures.Add(feature);
}
InMemoryFeatureLayer clippingLayer = new InMemoryFeatureLayer();
clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);
clippingLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
clippingLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("ClippingLayer", clippingLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
InMemoryFeatureLayer clipLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ClippingLayer"];
Feature clippingFeature = clipLayer.InternalFeatures.FirstOrDefault();
if (clippingFeature != null)
{
sourceLayer.Open();
Collection<Feature> features = sourceLayer.QueryTools.GetFeaturesIntersecting(clippingFeature.GetShape(), ReturningColumnsType.AllColumns);
sourceLayer.InternalFeatures.Clear();
clipLayer.InternalFeatures.Clear();
foreach (Feature feature in features)
{
sourceLayer.InternalFeatures.Add(feature.GetIntersection(clippingFeature));
}
}
layerOverlay.Refresh();
}
}
}
ConvexHullViewController.cs
using System.Collections.ObjectModel;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class ConvexHullViewController : DetailViewController
{
public ConvexHullViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(@"AppData/fire.png");
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
foreach (Feature feature in GeometrySource)
{
sourceLayer.InternalFeatures.Add(feature);
}
InMemoryFeatureLayer convexHullLayer = new InMemoryFeatureLayer();
convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
convexHullLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("ConvexHullLayer", convexHullLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
InMemoryFeatureLayer convexHullLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ConvexHullLayer"];
sourceLayer.Open();
Collection<Feature> features = sourceLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns);
convexHullLayer.Clear();
MultipointShape multipointShape = new MultipointShape();
foreach (PointShape pointShape in features.Skip(1).Select(feature => (PointShape)feature.GetShape()))
{
multipointShape.Points.Add(pointShape);
}
RingShape convexHull = multipointShape.ConvexHull();
PolygonShape polygonShape = new PolygonShape(convexHull);
convexHullLayer.InternalFeatures.Add(new Feature(polygonShape));
convexHullLayer.InternalFeatures.Add(features.FirstOrDefault().GetConvexHull());
layerOverlay.Refresh();
}
}
}
DifferenceViewController.cs
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class DifferenceViewController : DetailViewController
{
public DifferenceViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);
sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
if (sourceLayer.InternalFeatures.Count > 1)
{
AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape2"].GetShape();
AreaBaseShape targetShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape1"].GetShape();
AreaBaseShape resultShape = sourceShape.GetDifference(targetShape);
sourceLayer.InternalFeatures.Clear();
sourceLayer.InternalFeatures.Add(new Feature(resultShape.GetWellKnownBinary()));
layerOverlay.Refresh();
}
}
}
}
EnvelopViewController.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class EnvelopViewController : DetailViewController
{
public EnvelopViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add(GeometrySource.First());
InMemoryFeatureLayer boundingboxLayer = new InMemoryFeatureLayer();
boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));
boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);
boundingboxLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("BoundingboxLayer", boundingboxLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer boundingboxLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BoundingboxLayer"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature sourceFeature = sourceLayer.InternalFeatures.First();
boundingboxLayer.InternalFeatures.Clear();
boundingboxLayer.InternalFeatures.Add(new Feature(sourceFeature.GetBoundingBox()));
layerOverlay.Refresh();
}
}
}
GetAreaViewController.cs
using System.Globalization;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
using UIKit;
namespace GeometricFunctions
{
public class GetAreaViewController : DetailViewController
{
public GetAreaViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.Open();
sourceLayer.Columns.Add(new FeatureSourceColumn("Area"));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
TextStyle textStyle = new TextStyle();
textStyle.TextColumnName = "Area";
textStyle.Font = new GeoFont("Arial", 15);
textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;
textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;
textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);
textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);
textStyle.PointPlacement = PointPlacement.LowerCenter;
textStyle.YOffsetInPixel = -8;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add(GeometrySource.First());
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();
if (feature != null)
{
AreaBaseShape areaShape = (AreaBaseShape)feature.GetShape();
double metersArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.SquareMeters);
double hectaresArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.Hectares);
string areaMessage = string.Format(CultureInfo.InvariantCulture, "{0:N2} Hectares, \r\n {1:N2} Acres", metersArea, hectaresArea);
feature.ColumnValues["Area"] = areaMessage;
UIAlertView alertView = new UIAlertView("Area", areaMessage, null, "OK");
alertView.Show();
layerOverlay.Refresh();
}
}
}
}
GetLengthViewController.cs
using System.Globalization;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
using UIKit;
namespace GeometricFunctions
{
public class GetLengthViewController : DetailViewController
{
public GetLengthViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.Open();
sourceLayer.Columns.Add(new FeatureSourceColumn("Length"));
TextStyle textStyle = new TextStyle();
textStyle.TextColumnName = "Length";
textStyle.Font = new GeoFont("Arial", 15);
textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;
textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;
textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);
textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add(GeometrySource.First());
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();
if (firstFeature != null)
{
Feature feature = firstFeature.CloneDeep();
LineBaseShape lineShape = (LineBaseShape)feature.GetShape();
double length = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile);
string lengthContent = string.Format(CultureInfo.InvariantCulture, "Length is {0:N2} miles.", length);
feature.ColumnValues["Length"] = lengthContent;
sourceLayer.InternalFeatures.Clear();
sourceLayer.InternalFeatures.Add(feature);
UIAlertView alertView = new UIAlertView("Length", lengthContent, null, "OK");
alertView.Show();
layerOverlay.Refresh();
}
}
}
}
GetShortestLineViewController.cs
using System.Globalization;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class GetShortestLineViewController : DetailViewController
{
public GetShortestLineViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
RectangleShape mapExtent = ExtentHelper.GetBoundingBoxOfItems(GeometrySource);
mapExtent.ScaleUp(20);
MapView.CurrentExtent = mapExtent;
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);
sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);
InMemoryFeatureLayer shortestLineLayer = new InMemoryFeatureLayer();
shortestLineLayer.Open();
shortestLineLayer.Columns.Add(new FeatureSourceColumn("Distance"));
shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = GetTextStyle();
shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Width = 5;
shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Color = GeoColor.FromArgb(180, 255, 155, 13);
shortestLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("ShortestLineLayer", shortestLineLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
InMemoryFeatureLayer shortestLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ShortestLineLayer"];
BaseShape areaShape1 = sourceLayer.InternalFeatures["AreaShape1"].GetShape();
BaseShape areaShape2 = sourceLayer.InternalFeatures["AreaShape2"].GetShape();
MultilineShape multiLineShape = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter);
Feature feature = new Feature(multiLineShape.GetWellKnownBinary());
feature.ColumnValues["Distance"] = string.Format(CultureInfo.InvariantCulture, "Distance is {0:N2} miles.", multiLineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile));
shortestLineLayer.InternalFeatures.Clear();
shortestLineLayer.InternalFeatures.Add(feature);
layerOverlay.Refresh();
}
private static TextStyle GetTextStyle()
{
TextStyle textStyle = new TextStyle();
textStyle.TextColumnName = "Distance";
textStyle.Font = new GeoFont("Arial", 15);
textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;
textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;
textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);
textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);
textStyle.PointPlacement = PointPlacement.LowerCenter;
textStyle.YOffsetInPixel = -8;
return textStyle;
}
}
}
LineOnLineViewController.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class LineOnLineViewController : DetailViewController
{
public LineOnLineViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Circle, GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black, 18);
foreach (var feature in GeometrySource)
{
sourceLayer.InternalFeatures.Add(feature);
}
InMemoryFeatureLayer lineOnLineLayer = new InMemoryFeatureLayer();
lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;
lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Blue);
lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Red);
lineOnLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
layerOverlay.Layers.Add("LineOnLineLayer", lineOnLineLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer lineOnLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["LineOnLineLayer"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();
if (firstFeature != null)
{
LineShape lineShape = (LineShape)firstFeature.GetShape();
lineOnLineLayer.InternalFeatures.Clear();
LineBaseShape resultLine = lineShape.GetLineOnALine(StartingPoint.FirstPoint, 80, 450, GeographyUnit.Meter, DistanceUnit.Meter);
lineOnLineLayer.InternalFeatures.Add(new Feature(resultLine));
layerOverlay.Refresh();
}
}
}
}
RotateViewController.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class RotateViewController : DetailViewController
{
public RotateViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature sourceFeature = sourceLayer.InternalFeatures.FirstOrDefault();
if (sourceFeature != null && sourceFeature.GetShape().CanRotate)
{
PointShape center = sourceFeature.GetBoundingBox().GetCenterPoint();
BaseShape rotatedShape = BaseShape.Rotate(sourceFeature.GetShape(), center, 22.5f);
sourceLayer.InternalFeatures.Clear();
sourceLayer.InternalFeatures.Add(new Feature(rotatedShape));
layerOverlay.Refresh();
}
}
}
}
ScaleViewController.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class ScaleViewController : DetailViewController
{
public ScaleViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
Feature sourceFeature = GeometrySource.First();
sourceLayer.InternalFeatures.Add(sourceFeature.Id, sourceFeature);
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
Feature sourceFeature = sourceLayer.InternalFeatures.First();
sourceLayer.Open();
sourceLayer.EditTools.BeginTransaction();
sourceLayer.EditTools.ScaleUp(sourceFeature.Id, 10);
sourceLayer.EditTools.CommitTransaction();
layerOverlay.Refresh();
}
}
}
SimplifyViewContoller.cs
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class SimplifyViewController : DetailViewController
{
private static readonly double simplifyTolerence = 30;
public SimplifyViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
Feature feature = GeometrySource.FirstOrDefault();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
sourceLayer.InternalFeatures.Add(feature);
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures.FirstOrDefault().GetShape();
SimplificationType simplificationType = SimplificationType.DouglasPeucker;
MultipolygonShape multipolygonShape = sourceShape.Simplify(GeographyUnit.Meter, simplifyTolerence, DistanceUnit.Meter, simplificationType);
sourceLayer.InternalFeatures.Clear();
sourceLayer.InternalFeatures.Add(new Feature(multipolygonShape));
layerOverlay.Refresh();
}
}
}
SnapGPSViewController.cs
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class SnapGPSViewController : DetailViewController
{
private InMemoryFeatureLayer resultLayer;
private InMemoryFeatureLayer inProcessLayer;
public SnapGPSViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InitializeLayers();
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", inProcessLayer);
layerOverlay.Layers.Add("PointLayer", resultLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
resultLayer.InternalFeatures.Clear();
if (resultLayer.InternalFeatures.Count == 0)
{
inProcessLayer.IsVisible = false;
MultilineShape multilineShape = inProcessLayer.InternalFeatures[0].GetShape() as MultilineShape;
Feature[] allFeatures = { inProcessLayer.InternalFeatures[1] };
Collection<Feature> matchFeatures = new Collection<Feature>();
double tolerance = 100;
foreach (var item in allFeatures)
{
double tempDistance = multilineShape.GetShortestLineTo(item, GeographyUnit.Meter).GetLength(GeographyUnit.Meter, DistanceUnit.Feet);
if (tempDistance < tolerance)
{
matchFeatures.Add(item);
}
}
resultLayer.InternalFeatures.Add(new Feature(multilineShape));
foreach (var feature in matchFeatures)
{
Collection<Vertex> vertices = new Collection<Vertex>();
PointShape resultShape = multilineShape.GetClosestPointTo(feature, GeographyUnit.Meter);
MultilineShape tempMultilineShape = feature.GetShape() as MultilineShape;
if (tempMultilineShape != null)
{
vertices.Add(new Vertex(resultShape));
double offsetX = resultShape.X - tempMultilineShape.Lines[0].Vertices[0].X;
double offsetY = resultShape.Y - tempMultilineShape.Lines[0].Vertices[0].Y;
double x = offsetX + tempMultilineShape.Lines[0].Vertices[1].X;
double y = offsetY + tempMultilineShape.Lines[0].Vertices[1].Y;
vertices.Add(new Vertex(x, y));
}
resultLayer.InternalFeatures.Add(new Feature(new MultilineShape(new[] { new LineShape(vertices) })));
}
foreach (var feature in allFeatures)
{
if (!matchFeatures.Contains(feature))
{
resultLayer.InternalFeatures.Add(feature);
}
}
CollectVertices(resultLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);
}
layerOverlay.Refresh();
}
private void InitializeLayers()
{
inProcessLayer = new InMemoryFeatureLayer();
inProcessLayer.Open();
inProcessLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));
resultLayer = new InMemoryFeatureLayer();
resultLayer.Open();
resultLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));
GeoColor semiTransparentOrange = GeoColor.FromArgb(140, 255, 155, 13);
inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black);
inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 3, false);
inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Name", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black);
inProcessLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
foreach (var feature in GeometrySource)
{
inProcessLayer.InternalFeatures.Add(feature);
}
resultLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle;
resultLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 4, false);
resultLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
CollectVertices(inProcessLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);
}
private static void CollectVertices(IEnumerable<Feature> features, InMemoryFeatureLayer targetFeatureLayer)
{
foreach (var multilineShape in features.Select(f => f.GetShape()).OfType<MultilineShape>().Where(s => s != null))
{
foreach (var vertex in multilineShape.Lines.SelectMany(l => l.Vertices))
{
EllipseShape ellipseShape = new EllipseShape(new PointShape(vertex), 30);
targetFeatureLayer.InternalFeatures.Add(new Feature(ellipseShape));
}
}
}
}
}
SplitViewController.cs
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class SplitViewController : DetailViewController
{
public SplitViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();
worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;
MapView.Overlays.Add(worldOverlay);
MapView.Refresh();
}
}
}
UnionViewController.cs
using System.Collections.Generic;
using System.Linq;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
namespace GeometricFunctions
{
public class UnionViewController : DetailViewController
{
public UnionViewController()
{ }
protected override void InitializeMap()
{
MapView.MapUnit = GeographyUnit.Meter;
MapView.CurrentExtent = GetBoundingBox();
InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;
sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.SimpleColors.Black;
sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
foreach (Feature feature in GeometrySource)
{
sourceLayer.InternalFeatures.Add(feature);
}
LayerOverlay layerOverlay = new LayerOverlay();
layerOverlay.TileType = TileType.SingleTile;
layerOverlay.Layers.Add("SourceLayer", sourceLayer);
MapView.Overlays.Add("LayerOverlay", layerOverlay);
MapView.Refresh();
}
protected override void Execute()
{
LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];
InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];
if (sourceLayer.InternalFeatures.Count > 1)
{
IEnumerable<AreaBaseShape> areaBaseShapes = sourceLayer.InternalFeatures.Select(f => f.GetShape()).OfType<AreaBaseShape>();
AreaBaseShape unionedAreaBaseShape = AreaBaseShape.Union(areaBaseShapes);
sourceLayer.InternalFeatures.Clear();
sourceLayer.InternalFeatures.Add(new Feature(unionedAreaBaseShape));
layerOverlay.Refresh();
}
}
}
}
DetailViewController.cs
using CoreGraphics;
using Foundation;
using System;
using System.Collections.ObjectModel;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.iOSEdition;
using UIKit;
namespace GeometricFunctions
{
[Register("DetailViewController")]
public class DetailViewController : UIViewController
{
private GeoColor brushColor;
private UIBarButtonItem settingButton;
private Collection<Feature> geometrySource;
protected MapView MapView;
public Action DetailButtonClick;
protected DetailViewController()
{
geometrySource = new Collection<Feature>();
}
private void InitializeToolbar()
{
brushColor = GeoColor.FromArgb(100, 0, 147, 221);
UIBarButtonItem detailButton = new UIBarButtonItem(UIImage.FromBundle("detail40"), UIBarButtonItemStyle.Plain,
OnDetailItemClick);
detailButton.TintColor = UIColor.Black;
NavigationItem.SetLeftBarButtonItem(detailButton, true);
settingButton = new UIBarButtonItem("GO", UIBarButtonItemStyle.Plain, OnGoItemClick);
settingButton.TintColor = UIColor.Black;
NavigationItem.SetRightBarButtonItems(new[] { settingButton }, true);
}
public Collection<Feature> GeometrySource
{
get { return geometrySource; }
}
protected GeoColor BrushColor
{
get { return brushColor; }
}
protected RectangleShape GetBoundingBox()
{
RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();
mapExtent.ScaleUp(140);
return mapExtent;
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
View.AutoresizingMask = UIViewAutoresizing.FlexibleHeight | UIViewAutoresizing.FlexibleWidth;
MapView = new MapView(View.Frame);
MapView.BackgroundColor = UIColor.FromRGB(244, 242, 238);
MapView.MapTools.ZoomMapTool.Center = new CGPoint(MapView.MapTools.ZoomMapTool.Center.X + 10, MapView.MapTools.ZoomMapTool.Center.Y + 55);
LoadBackgroundLayer();
InitializeMap();
InitializeToolbar();
View.AddSubview(MapView);
}
public override void WillAnimateRotation(UIInterfaceOrientation toInterfaceOrientation, double duration)
{
base.WillAnimateRotation(toInterfaceOrientation, duration);
double resolution = Math.Max(MapView.CurrentExtent.Width / MapView.Frame.Width, MapView.CurrentExtent.Height / MapView.Frame.Height);
MapView.Frame = View.Bounds;
MapView.CurrentExtent = GetExtentRetainScale(MapView.CurrentExtent.GetCenterPoint(), MapView.Frame, resolution);
MapView.Refresh();
}
protected virtual void InitializeMap() { }
protected virtual void Execute() { }
private void LoadBackgroundLayer()
{
WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();
worldOverlay.TileType = TileType.MultiTile;
worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;
MapView.Overlays.Add("WMK", worldOverlay);
}
private static RectangleShape GetExtentRetainScale(PointShape currentLocationInMecator, CGRect frame, double resolution)
{
double left = currentLocationInMecator.X - resolution * frame.Width * .5;
double right = currentLocationInMecator.X + resolution * frame.Width * .5;
double top = currentLocationInMecator.Y + resolution * frame.Height * .5;
double bottom = currentLocationInMecator.Y - resolution * frame.Height * .5;
return new RectangleShape(left, top, right, bottom);
}
private void OnGoItemClick(object sender, EventArgs e)
{
settingButton.Enabled = false;
Execute();
settingButton.Enabled = true;
}
private void OnDetailItemClick(object sender, EventArgs e)
{
if (DetailButtonClick != null) DetailButtonClick();
}
}
}
SliderViewController.cs
using CoreGraphics;
using MonoTouch.Dialog;
using Foundation;
using MediaPlayer;
using ObjCRuntime;
using UIKit;
using System;
using System.Drawing;
namespace GeometricFunctions
{
public enum FlyOutPosition
{
Left = 0, // default
Right
};
[Register("SilderViewController")]
public class SliderViewController : UIViewController
{
private const float sidebarFlickVelocity = 1000.0f;
private const int menuWidth = 240;
private bool hideShadow;
private UIButton closeButton;
private FlyOutPosition position;
private DialogViewController leftNavigation;
private int selectedIndex;
private UIView shadowView;
private nfloat startX;
private UIView statusImage;
private UIViewController[] viewControllers;
private bool isIos7;
private bool isOpen;
public event UITouchEventArgs ShouldReceiveTouch;
public Action SelectedIndexChanged;
public SliderViewController(IntPtr handle)
: base(handle)
{
Initialize();
}
public SliderViewController(UITableViewStyle navigationStyle = UITableViewStyle.Plain)
{
Initialize(navigationStyle);
}
public FlyOutPosition Position
{
get
{
return position;
}
set
{
position = value;
shadowView.Layer.ShadowOffset = new CGSize(Position == FlyOutPosition.Left ? -5 : 5, -1);
}
}
public bool AlwaysShowLandscapeMenu { get; set; }
public bool ForceMenuOpen { get; set; }
public bool HideShadow
{
get { return hideShadow; }
set
{
if (value == hideShadow)
return;
hideShadow = value;
if (hideShadow)
{
if (mainView != null)
View.InsertSubviewBelow(shadowView, mainView);
}
else
{
shadowView.RemoveFromSuperview();
}
}
}
public UIColor ShadowViewColor
{
get { return shadowView.BackgroundColor; }
set { shadowView.BackgroundColor = value; }
}
public UIViewController CurrentViewController { get; set; }
public UIView mainView
{
get
{
if (CurrentViewController == null)
return null;
return CurrentViewController.View;
}
}
public RootElement NavigationRoot
{
get { return leftNavigation.Root; }
set { EnsureInvokedOnMainThread(delegate { leftNavigation.Root = value; }); }
}
public UITableView NavigationTableView
{
get { return leftNavigation.TableView; }
}
public UIViewController[] ViewControllers
{
get { return viewControllers; }
set
{
EnsureInvokedOnMainThread(delegate
{
viewControllers = value;
NavigationItemSelected(GetIndexPath(SelectedIndex));
});
}
}
public bool IsOpen
{
get
{
if (Position == FlyOutPosition.Left)
{
return mainView.Frame.X == menuWidth;
}
else
{
return mainView.Frame.X == -menuWidth;
}
}
set
{
isOpen = value;
if (value)
HideMenu();
else
ShowMenu();
}
}
public bool ShouldStayOpen
{
get
{
if (ForceMenuOpen || (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad &&
AlwaysShowLandscapeMenu && (InterfaceOrientation == UIInterfaceOrientation.LandscapeLeft
|| InterfaceOrientation == UIInterfaceOrientation.LandscapeRight)))
return true;
return false;
}
}
public int SelectedIndex
{
get { return selectedIndex; }
set
{
if (selectedIndex == value)
return;
selectedIndex = value;
EnsureInvokedOnMainThread(delegate { NavigationItemSelected(value); });
}
}
public bool DisableRotation { get; set; }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation)
{
if (DisableRotation)
return toInterfaceOrientation == InterfaceOrientation;
bool theReturn = CurrentViewController == null
? true
: CurrentViewController.ShouldAutorotateToInterfaceOrientation(toInterfaceOrientation);
return theReturn;
}
public override UIInterfaceOrientationMask GetSupportedInterfaceOrientations()
{
if (CurrentViewController != null)
return CurrentViewController.GetSupportedInterfaceOrientations();
return UIInterfaceOrientationMask.All;
}
public override void ViewDidLayoutSubviews()
{
base.ViewDidLayoutSubviews();
CGRect navFrame = View.Bounds;
// navFrame.Y += UIApplication.SharedApplication.StatusBarFrame.Height;
// navFrame.Height -= navFrame.Y;
//this.statusbar
navFrame.Width = menuWidth;
if (Position == FlyOutPosition.Right)
navFrame.X = mainView.Frame.Width - menuWidth;
if (leftNavigation.View.Frame != navFrame)
leftNavigation.View.Frame = navFrame;
}
public override void ViewWillAppear(bool animated)
{
CGRect navFrame = leftNavigation.View.Frame;
navFrame.Width = menuWidth;
if (Position == FlyOutPosition.Right)
navFrame.X = mainView.Frame.Width - menuWidth;
navFrame.Location = PointF.Empty;
leftNavigation.View.Frame = navFrame;
View.BackgroundColor = NavigationTableView.BackgroundColor;
var frame = mainView.Frame;
setViewSize();
SetLocation(frame);
base.ViewWillAppear(animated);
}
private void Initialize(UITableViewStyle navigationStyle = UITableViewStyle.Plain)
{
DisableStatusBarMoving = true;
statusImage = new UIView { ClipsToBounds = true }.SetAccessibilityId("statusbar");
leftNavigation = new DialogViewController(navigationStyle, null);
leftNavigation.OnSelection += NavigationItemSelected;
CGRect navFrame = leftNavigation.View.Frame;
navFrame.Width = menuWidth;
if (Position == FlyOutPosition.Right)
navFrame.X = mainView.Frame.Width - menuWidth;
leftNavigation.View.Frame = navFrame;
View.AddSubview(leftNavigation.View);
var version = new Version(UIDevice.CurrentDevice.SystemVersion);
isIos7 = version.Major >= 7;
if (isIos7)
{
leftNavigation.TableView.TableHeaderView = new UIView(new CGRect(0, 0, 320, 22))
{
BackgroundColor = UIColor.Clear
};
leftNavigation.TableView.SectionHeaderHeight = 50;
}
leftNavigation.TableView.TableFooterView = new UIView(new CGRect(0, 0, 100, 100)) { BackgroundColor = UIColor.Clear };
leftNavigation.TableView.ScrollsToTop = false;
shadowView = new UIView();
shadowView.BackgroundColor = UIColor.White;
shadowView.Layer.ShadowOffset = new CGSize(Position == FlyOutPosition.Left ? -5 : 5, -1);
shadowView.Layer.ShadowColor = UIColor.Black.CGColor;
shadowView.Layer.ShadowOpacity = .75f;
closeButton = new UIButton();
closeButton.TouchUpInside += delegate { HideMenu(); };
AlwaysShowLandscapeMenu = true;
View.AddGestureRecognizer(new OpenMenuGestureRecognizer(DragContentView, shouldReceiveTouch));
}
private void DragContentView(UIPanGestureRecognizer panGesture)
{
//if (ShouldStayOpen || mainView == null)
if (mainView == null)
return;
if (!HideShadow)
View.InsertSubviewBelow(shadowView, mainView);
leftNavigation.View.Hidden = false;
CGRect frame = mainView.Frame;
shadowView.Frame = frame;
nfloat translation = panGesture.TranslationInView(View).X;
if (panGesture.State == UIGestureRecognizerState.Began)
{
startX = frame.X;
}
else if (panGesture.State == UIGestureRecognizerState.Changed)
{
frame.X = translation + startX;
if (Position == FlyOutPosition.Left)
{
if (frame.X < 0)
frame.X = 0;
else if (frame.X > menuWidth)
frame.X = menuWidth;
}
else
{
if (frame.X > 0)
frame.X = 0;
else if (frame.X < -menuWidth)
frame.X = -menuWidth;
}
SetLocation(frame);
}
else if (panGesture.State == UIGestureRecognizerState.Ended)
{
nfloat velocity = panGesture.VelocityInView(View).X;
nfloat newX = translation + startX;
bool show = Math.Abs(velocity) > sidebarFlickVelocity ? velocity > 0 : newX > (menuWidth / 2);
if (Position == FlyOutPosition.Right)
{
show = Math.Abs(velocity) > sidebarFlickVelocity ? velocity < 0 : newX < -(menuWidth / 2);
}
if (show)
{
ShowMenu();
}
else
{
HideMenu();
}
}
}
private bool shouldReceiveTouch(UIGestureRecognizer gesture, UITouch touch)
{
if (ShouldReceiveTouch != null)
return ShouldReceiveTouch(gesture, touch);
return true;
}
private void NavigationItemSelected(NSIndexPath indexPath)
{
int index = GetIndex(indexPath);
NavigationItemSelected(index);
}
private void NavigationItemSelected(int index)
{
if (selectedIndex == index && CurrentViewController != null)
{
HideMenu();
return;
}
selectedIndex = index;
if (viewControllers == null || viewControllers.Length <= index || index < 0)
{
if (SelectedIndexChanged != null)
SelectedIndexChanged();
return;
}
if (ViewControllers[index] == null)
{
if (SelectedIndexChanged != null)
SelectedIndexChanged();
return;
}
if (!DisableStatusBarMoving)
//if (!DisableStatusBarMoving && !ShouldStayOpen)
UIApplication.SharedApplication.SetStatusBarHidden(false, UIStatusBarAnimation.Fade);
//bool isOpen = false;
//if (mainView != null)
//{
// mainView.RemoveFromSuperview();
// isOpen = IsOpen;
//}
//isOpen = false;
CurrentViewController = ViewControllers[SelectedIndex];
CGRect frame = View.Bounds;
//if (isOpen || ShouldStayOpen)
if (isOpen)
{
frame.X = Position == FlyOutPosition.Left ? menuWidth : -menuWidth;
frame.Width = frame.Width - frame.X;
}
//setViewSize();
SetLocation(frame);
View.AddSubview(mainView);
AddChildViewController(CurrentViewController);
//if (!ShouldStayOpen)
HideMenu();
if (SelectedIndexChanged != null)
SelectedIndexChanged();
}
//bool isOpen {get{ return mainView.Frame.X == menuWidth; }}
private void ShowMenu()
{
if (mainView == null)
return;
EnsureInvokedOnMainThread(delegate
{
//navigation.ReloadData ();
//isOpen = true;
leftNavigation.View.Hidden = false;
closeButton.Frame = mainView.Frame;
shadowView.Frame = mainView.Frame;
var statusFrame = statusImage.Frame;
statusFrame.X = mainView.Frame.X;
statusImage.Frame = statusFrame;
//if (!ShouldStayOpen)
View.AddSubview(closeButton);
if (!HideShadow)
View.InsertSubviewBelow(shadowView, mainView);
UIView.BeginAnimations("slideMenu");
UIView.SetAnimationCurve(UIViewAnimationCurve.EaseIn);
UIView.SetAnimationDuration(.3);
setViewSize();
CGRect frame = mainView.Frame;
frame.X = Position == FlyOutPosition.Left ? menuWidth : -menuWidth;
SetLocation(frame);
setViewSize();
frame = mainView.Frame;
shadowView.Frame = frame;
closeButton.Frame = frame;
statusFrame.X = mainView.Frame.X;
statusImage.Frame = statusFrame;
UIView.CommitAnimations();
isOpen = true;
});
}
private void setViewSize()
{
CGRect frame = View.Bounds;
//frame.Location = PointF.Empty;
//if (ShouldStayOpen)
if (isOpen)
frame.Width -= menuWidth;
if (mainView.Bounds == frame)
return;
mainView.Bounds = frame;
}
private void SetLocation(CGRect frame)
{
mainView.Layer.AnchorPoint = new CGPoint(.5f, .5f);
frame.Y = 0;
if (mainView.Frame.Location == frame.Location)
return;
frame.Size = mainView.Frame.Size;
var center = new CGPoint(frame.Left + frame.Width / 2,
frame.Top + frame.Height / 2);
mainView.Center = center;
shadowView.Center = center;
if (Math.Abs(frame.X - 0) > float.Epsilon)
{
getStatus();
var statusFrame = statusImage.Frame;
statusFrame.X = mainView.Frame.X;
statusImage.Frame = statusFrame;
}
}
private bool DisableStatusBarMoving { get; set; }
private void getStatus()
{
//if (DisableStatusBarMoving || !isIos7 || statusImage.Superview != null || ShouldStayOpen)
if (DisableStatusBarMoving || !isIos7 || statusImage.Superview != null)
return;
var image = captureStatusBarImage();
if (image == null)
return;
this.View.AddSubview(statusImage);
foreach (var view in statusImage.Subviews)
view.RemoveFromSuperview();
statusImage.AddSubview(image);
statusImage.Frame = UIApplication.SharedApplication.StatusBarFrame;
UIApplication.SharedApplication.StatusBarHidden = true;
}
private UIView captureStatusBarImage()
{
try
{
UIView screenShot = UIScreen.MainScreen.SnapshotView(false);
return screenShot;
}
catch (Exception ex)
{
return null;
}
}
private void hideStatus()
{
if (!isIos7)
return;
statusImage.RemoveFromSuperview();
UIApplication.SharedApplication.StatusBarHidden = false;
}
private void HideMenu()
{
//if (mainView == null || mainView.Frame.X == 0)
if (mainView == null)
return;
EnsureInvokedOnMainThread(delegate
{
isOpen = false;
leftNavigation.FinishSearch();
closeButton.RemoveFromSuperview();
shadowView.Frame = mainView.Frame;
var statusFrame = statusImage.Frame;
statusFrame.X = mainView.Frame.X;
statusImage.Frame = statusFrame;
UIView.Animate(.5, () =>
{
UIView.SetAnimationCurve(UIViewAnimationCurve.EaseInOut);
CGRect frame = View.Bounds;
frame.X = 0;
setViewSize();
SetLocation(frame);
shadowView.Frame = frame;
statusFrame.X = 0;
statusImage.Frame = statusFrame;
}, hideComplete);
});
}
[Export("animationEnded")]
private void hideComplete()
{
hideStatus();
shadowView.RemoveFromSuperview();
leftNavigation.View.Hidden = true;
}
private void ResignFirstResponders(UIView view)
{
if (view.Subviews == null)
return;
foreach (UIView subview in view.Subviews)
{
if (subview.IsFirstResponder)
subview.ResignFirstResponder();
ResignFirstResponders(subview);
}
}
public void ToggleMenu()
{
EnsureInvokedOnMainThread(delegate
{
if (!IsOpen && CurrentViewController != null && CurrentViewController.IsViewLoaded)
ResignFirstResponders(CurrentViewController.View);
if (IsOpen)
HideMenu();
else
ShowMenu();
});
}
private int GetIndex(NSIndexPath indexPath)
{
int section = 0;
int rowCount = 0;
while (section < indexPath.Section)
{
rowCount += leftNavigation.Root[section].Count;
section++;
}
return rowCount + indexPath.Row;
}
private NSIndexPath GetIndexPath(int index)
{
if (leftNavigation.Root == null)
return NSIndexPath.FromRowSection(0, 0);
int currentCount = 0;
int section = 0;
foreach (Section element in leftNavigation.Root)
{
if (element.Count + currentCount > index)
break;
currentCount += element.Count;
section++;
}
int row = index - currentCount;
return NSIndexPath.FromRowSection(row, section);
}
//public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation)
//{
// base.DidRotate(fromInterfaceOrientation);
// if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone)
// return;
// switch (InterfaceOrientation)
// {
// case UIInterfaceOrientation.LandscapeLeft:
// case UIInterfaceOrientation.LandscapeRight:
// ShowMenu();
// break;
// default:
// HideMenu();
// break;
// }
//}
private void EnsureInvokedOnMainThread(Action action)
{
if (NSThread.Current.IsMainThread)
{
action();
return;
}
BeginInvokeOnMainThread(() =>
action()
);
}
}
internal static class Helpers
{
static readonly IntPtr selAccessibilityIdentifier_Handle = Selector.GetHandle("accessibilityIdentifier");
public static UIView SetAccessibilityId(this UIView view, string id)
{
var nsId = NSString.CreateNative(id);
//Messaging.void_objc_msgSend_IntPtr(view.Handle, selAccessibilityIdentifier_Handle, nsId);
return view;
}
}
internal class OpenMenuGestureRecognizer : UIPanGestureRecognizer
{
public OpenMenuGestureRecognizer(Action<UIPanGestureRecognizer> callback, Func<UIGestureRecognizer, UITouch, bool> shouldReceiveTouch)
: base(callback)
{
ShouldReceiveTouch += (sender, touch) =>
{
//Ugly hack to ignore touches that are on a cell that is moving...
bool isMovingCell = touch.View.ToString().IndexOf("UITableViewCellReorderControl", StringComparison.InvariantCultureIgnoreCase) > -1;
if (touch.View is UISlider || touch.View is MPVolumeView || isMovingCell)
return false;
return shouldReceiveTouch(sender, touch);
};
}
}
}
AssemblyInfo.cs
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly:|AssemblyTitle("AnalyzingVisualization")]
[assembly: AssemblyDescription("")]
[assembly:|AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly:|AssemblyProduct("AnalyzingVisualization")]
[assembly: AssemblyCopyright("Copyright © 2015")]
[assembly:|AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly:|ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly:|Guid("84efb68d-6dbd-4d6e-a2e8-f4ef414d8ee0")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly:|AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("9.0.0.0")]
[assembly:|AssemblyFileVersion("9.0.0.0")]