From c1d170fe4df311e4b85d7d3ae32fe13abd704942 Mon Sep 17 00:00:00 2001
From: jperson_cp <SND\jperson_cp>
Date: Wed, 29 Jul 2009 16:30:41 +0000
Subject: [PATCH] Added missing type converters.

---
 GPS.NET (VS2008 Designers).csproj             |  23 ++-
 .../DilutionOfPrecisionConverter.cs           | 162 ++++++++++++++++++
 Type Converters/GpsNumericObjectConverter.cs  |  30 ++++
 .../SignalToNoiseRatioConverter.cs            | 159 +++++++++++++++++
 4 files changed, 365 insertions(+), 9 deletions(-)
 create mode 100644 Type Converters/DilutionOfPrecisionConverter.cs
 create mode 100644 Type Converters/GpsNumericObjectConverter.cs
 create mode 100644 Type Converters/SignalToNoiseRatioConverter.cs

diff --git a/GPS.NET (VS2008 Designers).csproj b/GPS.NET (VS2008 Designers).csproj
index 07379a6..2f34ac3 100644
--- a/GPS.NET (VS2008 Designers).csproj	
+++ b/GPS.NET (VS2008 Designers).csproj	
@@ -13,12 +13,15 @@
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>GeoFrameworks.snk</AssemblyOriginatorKeyFile>
-    <SccProjectName>SurroundSCMScci</SccProjectName>
-    <SccLocalPath>.</SccLocalPath>
+    <AssemblyOriginatorKeyFile>CodePlex.snk</AssemblyOriginatorKeyFile>
+    <SccProjectName>
+    </SccProjectName>
+    <SccLocalPath>
+    </SccLocalPath>
     <SccAuxPath>
     </SccAuxPath>
-    <SccProvider>MSSCCI:Surround SCM</SccProvider>
+    <SccProvider>
+    </SccProvider>
     <RunPostBuildEvent>OnOutputUpdated</RunPostBuildEvent>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -43,10 +46,6 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="GeoFramework.Design, Version=1.0.50727.0, Culture=neutral, PublicKeyToken=3ed3cdf4fdda3400, processorArchitecture=MSIL">
-      <HintPath>..\..\GeoFramework\1.4.7\bin\Debug\VS2008 Designers\GeoFramework.Design.dll</HintPath>
-      <SpecificVersion>False</SpecificVersion>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Windows.Forms" />
   </ItemGroup>
@@ -57,7 +56,13 @@
     <Compile Include="Type Converters\SignalToNoiseRatioConverter.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="GeoFrameworks.snk" />
+    <None Include="CodePlex.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\GeoFramework\2.0.0 Open Source\GeoFramework %28VS2008 Designers%29.csproj">
+      <Project>{7F9F4CB4-F86D-45F0-8FA0-00C5E19B72A0}</Project>
+      <Name>GeoFramework %28VS2008 Designers%29</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Type Converters/DilutionOfPrecisionConverter.cs b/Type Converters/DilutionOfPrecisionConverter.cs
new file mode 100644
index 0000000..19fb0e0
--- /dev/null
+++ b/Type Converters/DilutionOfPrecisionConverter.cs	
@@ -0,0 +1,162 @@
+#if !PocketPC || DesignTime
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System;
+using System.Globalization;
+using System.Text;
+using System.Reflection;
+using System.Windows.Forms;
+
+#if !Framework20
+using GeoFramework.Gps;
+#endif
+
+namespace GeoFramework.Design
+{
+    /// <summary>
+    /// Provides functionality to convert string values to and from DilutionOfPrecision objects at design time.
+    /// </summary>
+#if Framework20
+    public sealed class DilutionOfPrecisionConverter : GpsNumericObjectConverter
+    {
+        protected override string HandledTypeName
+        {
+            get
+            {
+                return "GeoFramework.Gps.DilutionOfPrecision";
+            }
+        }
+
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            // What is the destination type?
+            if (destinationType == typeof(string) && value == null)
+            {
+                return "0�";
+            }
+            else if (destinationType == typeof(InstanceDescriptor))
+            {
+                // Instance descriptor.  Used during Windows Forms serialization.
+
+                // Get the type of the object (probably an Angle)
+                Type DilutionOfPrecisionType = value.GetType();
+                // Is the value null?
+                if (value == null)
+                {
+                    // Yes.  Return the "Empty" static value
+                    return new InstanceDescriptor(DilutionOfPrecisionType.GetField("Empty"), null);
+                }
+                else
+                {
+                    // Build the parameters for the type converter
+                    object[] ConstructorParameters = new object[] { DilutionOfPrecisionType.GetProperty("Value").GetValue(value, null) };
+                    Type[] ConstructorTypes = new Type[] { typeof(double) };
+
+                    // Now activate the constructor
+                    ConstructorInfo Constructor = DilutionOfPrecisionType.GetConstructor(ConstructorTypes);
+                    return new InstanceDescriptor(Constructor, ConstructorParameters);
+                }
+            }
+
+            // Defer to the base class
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
+        {
+            return true;
+        }
+
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
+        {
+            return new StandardValuesCollection(new string[] {
+		            "Ideal",
+		            "Excellent",
+                    "Good",
+                    "Moderate",
+		            "Fair",
+		            "Poor"		            
+		             });
+        }
+
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
+        {
+            return false;
+        }
+    }
+#else
+	public class DilutionOfPrecisionConverter : ExpandableObjectConverter
+	{
+		#region ConvertFrom: Converts an object to an DilutionOfPrecision
+
+		// Indicates if the type can be converted
+		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+		{
+			if (sourceType.Equals(typeof(string))
+				|| sourceType.Equals(typeof(double))
+				|| sourceType.Equals(typeof(InstanceDescriptor))
+				|| sourceType.Equals(typeof(DilutionOfPrecision)))
+				return true;
+			// Defer to the base class
+			return base.CanConvertFrom(context, sourceType);
+		}
+
+		// Converts an object of one type to an DilutionOfPrecision
+		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
+		{
+			Type ValueType = value.GetType();
+			if (ValueType.Equals(typeof(string)))
+				return new DilutionOfPrecision((string)value, culture);
+			else if (ValueType.Equals(typeof(double)))
+				return new DilutionOfPrecision((double)value);
+			else if (ValueType.Equals(typeof(DilutionOfPrecision)))
+				return value;
+			// Defer to the base class
+			return base.ConvertFrom(context, culture, value);
+		}
+
+		#endregion
+
+		#region ConvertTo: Converts an DilutionOfPrecision to another type
+
+		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+		{
+			if (destinationType.Equals(typeof(string))
+				|| destinationType.Equals(typeof(double))
+				|| destinationType.Equals(typeof(InstanceDescriptor))
+				|| destinationType.Equals(typeof(DilutionOfPrecision)))
+				return true;
+			// Defer to the base class
+			return base.CanConvertTo(context, destinationType);
+		}
+
+
+		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+		{
+			if(destinationType.Equals(value.GetType()))
+				return value;
+			else if (destinationType.Equals(typeof(string)))
+				return value.ToString();
+			else if (destinationType.Equals(typeof(double)))
+				return ((SignalToNoiseRatio)value).Value;
+			else if (destinationType.Equals(typeof(SignalToNoiseRatio)))
+				return value;
+			else if(destinationType == typeof(InstanceDescriptor))
+			{
+				ConstructorInfo Constructor = typeof(DilutionOfPrecision).GetConstructor(
+					new Type[] {typeof(double)});
+				DilutionOfPrecision dilutionOfPrecision = (DilutionOfPrecision)value;
+				return new InstanceDescriptor(Constructor, new object[] { dilutionOfPrecision.Value });
+			}
+			// Defer to the base class
+			return base.ConvertTo(context, culture, value, destinationType);
+		}
+
+		#endregion
+	}
+#endif
+}
+#endif
\ No newline at end of file
diff --git a/Type Converters/GpsNumericObjectConverter.cs b/Type Converters/GpsNumericObjectConverter.cs
new file mode 100644
index 0000000..37a4bd8
--- /dev/null
+++ b/Type Converters/GpsNumericObjectConverter.cs	
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GeoFramework.Design
+{
+    public abstract class GpsNumericObjectConverter : GeoFrameworkNumericObjectConverter
+    {
+
+        protected override Version HandledAssemblyVersion
+        {
+            get
+            {
+                return new Version("2.3.1.0");
+            }
+        }
+
+        protected override string HandledAssemblyName
+        {
+            get
+            {
+#if PocketPC
+                return "GeoFramework.Gps.PocketPC, Culture=neutral, Version=" + HandledAssemblyVersion.ToString(4) + ", PublicKeyToken=3ed3cdf4fdda3400";
+#else
+                return "GeoFramework.Gps, Culture=neutral, Version=" + HandledAssemblyVersion.ToString(4) + ", PublicKeyToken=3ed3cdf4fdda3400";
+#endif
+            }
+        }
+    }
+}
diff --git a/Type Converters/SignalToNoiseRatioConverter.cs b/Type Converters/SignalToNoiseRatioConverter.cs
new file mode 100644
index 0000000..fa314eb
--- /dev/null
+++ b/Type Converters/SignalToNoiseRatioConverter.cs	
@@ -0,0 +1,159 @@
+#if !PocketPC || DesignTime
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System;
+using System.Globalization;
+using System.Text;
+using System.Reflection;
+using System.Windows.Forms;
+
+#if !Framework20
+using GeoFramework.Gps;
+#endif
+
+namespace GeoFramework.Design
+{
+    /// <summary>
+    /// Provides functionality to convert string values to and from SignalToNoiseRatio objects at design time.
+    /// </summary>
+#if Framework20
+    public sealed class SignalToNoiseRatioConverter : GpsNumericObjectConverter
+    {
+        protected override string HandledTypeName
+        {
+            get
+            {
+                return "GeoFramework.Gps.SignalToNoiseRatio";
+            }
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            // What is the destination type?
+            if (destinationType == typeof(string) && value == null)
+            {
+                return "0";
+            }
+            else if (destinationType == typeof(InstanceDescriptor))
+            {
+                // Instance descriptor.  Used during Windows Forms serialization.
+
+                // Get the type of the object (probably an SignalToNoiseRatio)
+                Type SignalToNoiseRatioType = value.GetType();
+                // Is the value null?
+                if (value == null)
+                {
+                    // Yes.  Return the "Empty" static value
+                    return new InstanceDescriptor(SignalToNoiseRatioType.GetField("Empty"), null);
+                }
+                else
+                {
+                    // Build the parameters for the type converter
+                    object[] ConstructorParameters = new object[] { SignalToNoiseRatioType.GetProperty("Value").GetValue(value, null) };
+                    Type[] ConstructorTypes = new Type[] { typeof(double) };
+
+                    // Now activate the constructor
+                    ConstructorInfo Constructor = SignalToNoiseRatioType.GetConstructor(ConstructorTypes);
+                    return new InstanceDescriptor(Constructor, ConstructorParameters);
+                }
+            }
+
+            // Defer to the base class
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
+        {
+            return true;
+        }
+
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
+        {
+            return new StandardValuesCollection(new string[] {
+		            "FullSignal",
+		            "HalfSignal",
+                    "NoSignal"	            
+		             });
+        }
+
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
+        {
+            return false;
+        }
+    }
+#else
+	public sealed class SignalToNoiseRatioConverter : ExpandableObjectConverter
+	{
+		#region ConvertFrom: Converts an object to an SignalToNoiseRatio
+
+		// Indicates if the type can be converted
+		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+		{
+			if (sourceType.Equals(typeof(string))
+				|| sourceType.Equals(typeof(int))
+				|| sourceType.Equals(typeof(InstanceDescriptor))
+				|| sourceType.Equals(typeof(SignalToNoiseRatio)))
+				return true;
+			// Defer to the base class
+			return base.CanConvertFrom(context, sourceType);
+		}
+
+		// Converts an object of one type to an SignalToNoiseRatio
+		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
+		{
+			Type ValueType = value.GetType();
+			if (ValueType.Equals(typeof(string)))
+				return new SignalToNoiseRatio((string)value, culture);
+			else if (ValueType.Equals(typeof(double)))
+				return new SignalToNoiseRatio((int)value);
+			else if (ValueType.Equals(typeof(SignalToNoiseRatio)))
+				return value;
+			// Defer to the base class
+			return base.ConvertFrom(context, culture, value);
+		}
+
+		#endregion
+
+		#region ConvertTo: Converts an SignalToNoiseRatio to another type
+
+		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+		{
+			if (destinationType.Equals(typeof(string))
+				|| destinationType.Equals(typeof(int))
+				|| destinationType.Equals(typeof(InstanceDescriptor))
+				|| destinationType.Equals(typeof(SignalToNoiseRatio)))
+				return true;
+			// Defer to the base class
+			return base.CanConvertTo(context, destinationType);
+		}
+
+
+		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+		{
+			if(destinationType.Equals(value.GetType()))
+				return value;
+			else if (destinationType.Equals(typeof(string)))
+				return value.ToString();
+			else if (destinationType.Equals(typeof(int)))
+				return ((SignalToNoiseRatio)value).Value;
+			else if (destinationType.Equals(typeof(SignalToNoiseRatio)))
+				return value;
+			if (destinationType == typeof(InstanceDescriptor))
+			{
+				ConstructorInfo Constructor = typeof(SignalToNoiseRatio).GetConstructor(
+					new Type[] { typeof(int) });
+				SignalToNoiseRatio SignalToNoiseRatio = (SignalToNoiseRatio)value;
+				return new InstanceDescriptor(Constructor, new object[] { SignalToNoiseRatio.Value });
+			}
+			// Defer to the base class
+			return base.ConvertTo(context, culture, value, destinationType);
+		}
+
+		#endregion
+	}
+#endif
+}
+#endif
\ No newline at end of file