Merged in develop (pull request #6)

Release 0.5.0.0

* Removed unwanted files

* Adding git ignore file

* Started working on getting the basic communications with the scope working.
    Working on routines to get and set the date and time in the handbox.

* Switched the serial port over to using the .net frameworks serial port.
    Extracted the serial port into it's own class and created a simpler command processing mechanism.

* Implemented AbortSlew and did some code tidy up.

* Forced all code to 64-bit only, will make this 32/64 bit before release.
    Fixed issue in the SerialProcessor when setting the time, makes sure that there's no chance of thread stealing when pulling out the junk messages
    Added ConformanceResult.txt to show the progress of the driver development

* Added code for the site latitude
    and started work on the longitude.

* Added unit tests for reading and writing the utcDate.
    Fixed a couple of defects in the code that was setting the utcDate.

* Corrected Longitude value range

* Added support for UTC offset.

* Pulse guiding support added

* Added SiteLatitude unit tests

* Added unit tests for SiteLongitude

* Added unit tests for the new Pulse guide implementation.

* Added support for AlignmentMode

* Added support for AtPark and Park

* Added support for parking the scope
    Added support for reading the scope Azimuth

* Added support for reading Declination

* Added 5 second timeout for the serial port.
    Fixed problem with the GW command not working on the Autostar 497.

* Fixed broken unit test

* Added support for altitude

* Tidying up resharper warinings

* Implemented RightAscension
    TargetRightAscension
    TargetDec
    SlewToCoord
    and SlewToCoordAsync

* Sorted out the target RA and Dec exceptions to be compliant with ascom.

* Implemented SlewToAltAz and SlewToAltAzAsync

* Implemented SyncToTarget functionality

* Implemented slew to target

* Added support for MoveAxis

* Added support for tracking rate

* Added IFocuserV3 to the driver and made sure that it's registered for ASCOM as a focuser as well.

* Fixed issue with Target RA and Dec loosing precision

* Telescope driver now passes the Ascom conformance.

* Upgraded driver version to 0.1

* Added explicit locks around all sequences of commands.

* Basic implementation of the IFocusserV3

* Focuser passes validation, this makes the code V0.2

* Added support for CommandBlind and CommandString
    Modified the tracking rates to be setable.  However, the get is now simulated.

* Merged in feature/LocalServer (pull request #5)

    Feature/LocalServer

    * Major refactor.  Switching over to a local server hub style driver allowing multiple programs to control the telescope at one time without the need for the POTH Hub

    * Unified the setup dialog

    * Implemented shared serial port, Both Telescope and Driver can connect at the same time.

    * Ported the focuser implementation from the non server based version.

    * Ported the telescope driver code.

    * Fixed problem with # not being stripped from the returned string ends. Fixed issue with RA being returned as degress rather than hours.

    * Telescope passes validation

    * Added a lock around the focuser move.

    * Reimplemented CommandBlind and CommandString

    * Corrected version information

    * Removed the Altitude support as there's a bug in the Autostar and Audiostar firmware

* Added comments for all meade commands.
    Fixed the Site Lat and Long setters

* Re instated the Altitude value and ran conformance for both the telescope and focuser.

* Redesigned the Altitude and Azimuth readings to use the Right Ascension and Declination co-ordinates and perform the transformation using the date and site details from the scope.   This will correct the problem of the Altitude reading from the handset being incorrect.

* Added code to make sure that the scope returns values in high precision mode.

* Fixed problem where SlewToAltAz didn't work correctly.  Now uses the RA/Dec slew for everything, and converts the values as needed.

* Upgraded the error handling to ensure that all serial commands are executed after checking that there is a connection open.

* Added some code to the focuser connect to make it consistent with the telescope connect in that it will now test that the connection is to an Autostar.

    Upgraded the move code to make it less unreliable.

* Added localisation support

* First draft of the installer

* Sorted out the registry settings needed to get the driver working properly on install.

* Modified the solution to be able to create as 32-bit install that works on 64bit windows 10.

* Added a call to activate when the setup dialog is shown.

Meade.net/ClassFactory.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Collections;
+
+namespace ASCOM.Meade.net
+{
+
+    #region C# Definition of IClassFactory
+    //
+    // Provide a definition of theCOM IClassFactory interface.
+    //
+    [
+      ComImport,                                                // This interface originated from COM.
+      ComVisible(false),                                        // Must not be exposed to COM!!!
+      InterfaceType(ComInterfaceType.InterfaceIsIUnknown),      // Indicate that this interface is not IDispatch-based.
+      Guid("00000001-0000-0000-C000-000000000046")              // This GUID is the actual GUID of IClassFactory.
+    ]
+    public interface IClassFactory
+    {
+        void CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject);
+        void LockServer(bool fLock);
+    }
+    #endregion
+
+    //
+    // Universal ClassFactory. Given a type as a parameter of the 
+    // constructor, it implements IClassFactory for any interface
+    // that the class implements. Magic!!!
+    //
+    public class ClassFactory : IClassFactory
+    {
+
+        #region Access to ole32.dll functions for class factories
+
+        // Define two common GUID objects for public usage.
+        public static Guid IID_IUnknown = new Guid("{00000000-0000-0000-C000-000000000046}");
+        public static Guid IID_IDispatch = new Guid("{00020400-0000-0000-C000-000000000046}");
+
+        [Flags]
+        enum CLSCTX : uint
+        {
+            CLSCTX_INPROC_SERVER = 0x1,
+            CLSCTX_INPROC_HANDLER = 0x2,
+            CLSCTX_LOCAL_SERVER = 0x4,
+            CLSCTX_INPROC_SERVER16 = 0x8,
+            CLSCTX_REMOTE_SERVER = 0x10,
+            CLSCTX_INPROC_HANDLER16 = 0x20,
+            CLSCTX_RESERVED1 = 0x40,
+            CLSCTX_RESERVED2 = 0x80,
+            CLSCTX_RESERVED3 = 0x100,
+            CLSCTX_RESERVED4 = 0x200,
+            CLSCTX_NO_CODE_DOWNLOAD = 0x400,
+            CLSCTX_RESERVED5 = 0x800,
+            CLSCTX_NO_CUSTOM_MARSHAL = 0x1000,
+            CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000,
+            CLSCTX_NO_FAILURE_LOG = 0x4000,
+            CLSCTX_DISABLE_AAA = 0x8000,
+            CLSCTX_ENABLE_AAA = 0x10000,
+            CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000,
+            CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
+            CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
+            CLSCTX_ALL = CLSCTX_SERVER | CLSCTX_INPROC_HANDLER
+        }
+
+        [Flags]
+        enum REGCLS : uint
+        {
+            REGCLS_SINGLEUSE = 0,
+            REGCLS_MULTIPLEUSE = 1,
+            REGCLS_MULTI_SEPARATE = 2,
+            REGCLS_SUSPENDED = 4,
+            REGCLS_SURROGATE = 8
+        }
+        //
+        // CoRegisterClassObject() is used to register a Class Factory
+        // into COM's internal table of Class Factories.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoRegisterClassObject(
+            [In] ref Guid rclsid,
+            [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
+            uint dwClsContext,
+            uint flags,
+            out uint lpdwRegister);
+        //
+        // Called by a COM EXE Server that can register multiple class objects 
+        // to inform COM about all registered classes, and permits activation 
+        // requests for those class objects. 
+        // This function causes OLE to inform the SCM about all the registered 
+        // classes, and begins letting activation requests into the server process.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoResumeClassObjects();
+        //
+        // Prevents any new activation requests from the SCM on all class objects
+        // registered within the process. Even though a process may call this API, 
+        // the process still must call CoRevokeClassObject for each CLSID it has 
+        // registered, in the apartment it registered in.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoSuspendClassObjects();
+        //
+        // CoRevokeClassObject() is used to unregister a Class Factory
+        // from COM's internal table of Class Factories.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoRevokeClassObject(uint dwRegister);
+        #endregion
+
+        #region Constructor and Private ClassFactory Data
+
+        protected Type m_ClassType;
+        protected Guid m_ClassId;
+        protected ArrayList m_InterfaceTypes;
+        protected uint m_ClassContext;
+        protected uint m_Flags;
+        protected UInt32 m_locked = 0;
+        protected uint m_Cookie;
+        protected string m_progid;
+
+        public ClassFactory(Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            m_ClassType = type;
+
+            //PWGS Get the ProgID from the MetaData
+            m_progid = Marshal.GenerateProgIdForType(type);
+            m_ClassId = Marshal.GenerateGuidForType(type);		// Should be nailed down by [Guid(...)]
+            m_ClassContext = (uint)CLSCTX.CLSCTX_LOCAL_SERVER;	// Default
+            m_Flags = (uint)REGCLS.REGCLS_MULTIPLEUSE |			// Default
+                        (uint)REGCLS.REGCLS_SUSPENDED;
+            m_InterfaceTypes = new ArrayList();
+            foreach (Type T in type.GetInterfaces())            // Save all of the implemented interfaces
+                m_InterfaceTypes.Add(T);
+        }
+
+        #endregion
+
+        #region Common ClassFactory Methods
+        public uint ClassContext
+        {
+            get { return m_ClassContext; }
+            set { m_ClassContext = value; }
+        }
+
+        public Guid ClassId
+        {
+            get { return m_ClassId; }
+            set { m_ClassId = value; }
+        }
+
+        public uint Flags
+        {
+            get { return m_Flags; }
+            set { m_Flags = value; }
+        }
+
+        public bool RegisterClassObject()
+        {
+            // Register the class factory
+            int i = CoRegisterClassObject
+                (
+                ref m_ClassId,
+                this,
+                m_ClassContext,
+                m_Flags,
+                out m_Cookie
+                );
+            return (i == 0);
+        }
+
+        public bool RevokeClassObject()
+        {
+            int i = CoRevokeClassObject(m_Cookie);
+            return (i == 0);
+        }
+
+        public static bool ResumeClassObjects()
+        {
+            int i = CoResumeClassObjects();
+            return (i == 0);
+        }
+
+        public static bool SuspendClassObjects()
+        {
+            int i = CoSuspendClassObjects();
+            return (i == 0);
+        }
+        #endregion
+
+        #region IClassFactory Implementations
+        //
+        // Implement creation of the type and interface.
+        //
+        void IClassFactory.CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject)
+        {
+            IntPtr nullPtr = new IntPtr(0);
+            ppvObject = nullPtr;
+
+            //
+            // Handle specific requests for implemented interfaces
+            //
+            foreach (Type iType in m_InterfaceTypes)
+            {
+                if (riid == Marshal.GenerateGuidForType(iType))
+                {
+                    ppvObject = Marshal.GetComInterfaceForObject(Activator.CreateInstance(m_ClassType), iType);
+                    return;
+                }
+            }
+            //
+            // Handle requests for IDispatch or IUnknown on the class
+            //
+            if (riid == IID_IDispatch)
+            {
+                ppvObject = Marshal.GetIDispatchForObject(Activator.CreateInstance(m_ClassType));
+                return;
+            }
+            else if (riid == IID_IUnknown)
+            {
+                ppvObject = Marshal.GetIUnknownForObject(Activator.CreateInstance(m_ClassType));
+            }
+            else
+            {
+                //
+                // Oops, some interface that the class doesn't implement
+                //
+                throw new COMException("No interface", unchecked((int)0x80004002));
+            }
+        }
+
+        void IClassFactory.LockServer(bool bLock)
+        {
+            if (bLock)
+                Server.CountLock();
+            else
+                Server.UncountLock();
+            // Always attempt to see if we need to shutdown this server application.
+            Server.ExitIf();
+        }
+        #endregion
+    }
+}

Meade.net/GarbageCollection.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Threading;
+
+namespace ASCOM.Meade.net
+{
+    /// <summary>
+    /// Summary description for GarbageCollection.
+    /// </summary>
+    class GarbageCollection
+    {
+        protected bool m_bContinueThread;
+        protected bool m_GCWatchStopped;
+        protected int m_iInterval;
+        protected ManualResetEvent m_EventThreadEnded;
+
+        public GarbageCollection(int iInterval)
+        {
+            m_bContinueThread = true;
+            m_GCWatchStopped = false;
+            m_iInterval = iInterval;
+            m_EventThreadEnded = new ManualResetEvent(false);
+        }
+
+        public void GCWatch()
+        {
+            // Pause for a moment to provide a delay to make threads more apparent.
+            while (ContinueThread())
+            {
+                GC.Collect();
+                Thread.Sleep(m_iInterval);
+            }
+            m_EventThreadEnded.Set();
+        }
+
+        protected bool ContinueThread()
+        {
+            lock (this)
+            {
+                return m_bContinueThread;
+            }
+        }
+
+        public void StopThread()
+        {
+            lock (this)
+            {
+                m_bContinueThread = false;
+            }
+        }
+
+        public void WaitForThreadToStop()
+        {
+            m_EventThreadEnded.WaitOne();
+            m_EventThreadEnded.Reset();
+        }
+    }
+}

Meade.net/LocalServer.cs

@@ -0,0 +1,642 @@
+//
+// ASCOM.Meade.net Local COM Server
+//
+// This is the core of a managed COM Local Server, capable of serving
+// multiple instances of multiple interfaces, within a single
+// executable. This implementes the equivalent functionality of VB6
+// which has been extensively used in ASCOM for drivers that provide
+// multiple interfaces to multiple clients (e.g. Meade Telescope
+// and Focuser) as well as hubs (e.g., POTH).
+//
+// Written by: Robert B. Denny (Version 1.0.1, 29-May-2007)
+// Modified by Chris Rowland and Peter Simpson to allow use with multiple devices of the same type March 2011
+//
+//
+using System;
+using System.IO;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Collections;
+using System.Runtime.InteropServices;
+using System.Reflection;
+using ASCOM.Utilities;
+using Microsoft.Win32;
+using System.Text;
+using System.Threading;
+using System.Security.Principal;
+using System.Diagnostics;
+using ASCOM;
+
+namespace ASCOM.Meade.net
+{
+    public static class Server
+    {
+
+        #region Access to kernel32.dll, user32.dll, and ole32.dll functions
+        [Flags]
+        enum CLSCTX : uint
+        {
+            CLSCTX_INPROC_SERVER = 0x1,
+            CLSCTX_INPROC_HANDLER = 0x2,
+            CLSCTX_LOCAL_SERVER = 0x4,
+            CLSCTX_INPROC_SERVER16 = 0x8,
+            CLSCTX_REMOTE_SERVER = 0x10,
+            CLSCTX_INPROC_HANDLER16 = 0x20,
+            CLSCTX_RESERVED1 = 0x40,
+            CLSCTX_RESERVED2 = 0x80,
+            CLSCTX_RESERVED3 = 0x100,
+            CLSCTX_RESERVED4 = 0x200,
+            CLSCTX_NO_CODE_DOWNLOAD = 0x400,
+            CLSCTX_RESERVED5 = 0x800,
+            CLSCTX_NO_CUSTOM_MARSHAL = 0x1000,
+            CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000,
+            CLSCTX_NO_FAILURE_LOG = 0x4000,
+            CLSCTX_DISABLE_AAA = 0x8000,
+            CLSCTX_ENABLE_AAA = 0x10000,
+            CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000,
+            CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
+            CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
+            CLSCTX_ALL = CLSCTX_SERVER | CLSCTX_INPROC_HANDLER
+        }
+
+        [Flags]
+        enum COINIT : uint
+        {
+            /// Initializes the thread for multi-threaded object concurrency.
+            COINIT_MULTITHREADED = 0x0,
+            /// Initializes the thread for apartment-threaded object concurrency. 
+            COINIT_APARTMENTTHREADED = 0x2,
+            /// Disables DDE for Ole1 support.
+            COINIT_DISABLE_OLE1DDE = 0x4,
+            /// Trades memory for speed.
+            COINIT_SPEED_OVER_MEMORY = 0x8
+        }
+
+        [Flags]
+        enum REGCLS : uint
+        {
+            REGCLS_SINGLEUSE = 0,
+            REGCLS_MULTIPLEUSE = 1,
+            REGCLS_MULTI_SEPARATE = 2,
+            REGCLS_SUSPENDED = 4,
+            REGCLS_SURROGATE = 8
+        }
+
+
+        // CoInitializeEx() can be used to set the apartment model
+        // of individual threads.
+        [DllImport("ole32.dll")]
+        static extern int CoInitializeEx(IntPtr pvReserved, uint dwCoInit);
+
+        // CoUninitialize() is used to uninitialize a COM thread.
+        [DllImport("ole32.dll")]
+        static extern void CoUninitialize();
+
+        // PostThreadMessage() allows us to post a Windows Message to
+        // a specific thread (identified by its thread id).
+        // We will need this API to post a WM_QUIT message to the main 
+        // thread in order to terminate this application.
+        [DllImport("user32.dll")]
+        static extern bool PostThreadMessage(uint idThread, uint Msg, UIntPtr wParam,
+            IntPtr lParam);
+
+        // GetCurrentThreadId() allows us to obtain the thread id of the
+        // calling thread. This allows us to post the WM_QUIT message to
+        // the main thread.
+        [DllImport("kernel32.dll")]
+        static extern uint GetCurrentThreadId();
+        #endregion
+
+        #region Private Data
+        private static int objsInUse;                       // Keeps a count on the total number of objects alive.
+        private static int serverLocks;                     // Keeps a lock count on this application.
+        private static frmMain s_MainForm = null;               // Reference to our main form
+        private static ArrayList s_ComObjectAssys;              // Dynamically loaded assemblies containing served COM objects
+        private static ArrayList s_ComObjectTypes;              // Served COM object types
+        private static ArrayList s_ClassFactories;              // Served COM object class factories
+        private static string s_appId = "{4e68ec46-5ffc-49e7-b298-38a548df0bfd}";	// Our AppId
+        private static readonly Object lockObject = new object();
+        #endregion
+
+        // This property returns the main thread's id.
+        public static uint MainThreadId { get; private set; }   // Stores the main thread's thread id.
+
+        // Used to tell if started by COM or manually
+        public static bool StartedByCOM { get; private set; }   // True if server started by COM (-embedding)
+
+
+        #region Server Lock, Object Counting, and AutoQuit on COM startup
+        // Returns the total number of objects alive currently.
+        public static int ObjectsCount
+        {
+            get
+            {
+                lock (lockObject)
+                {
+                    return objsInUse;
+                }
+            }
+        }
+
+        // This method performs a thread-safe incrementation of the objects count.
+        public static int CountObject()
+        {
+            // Increment the global count of objects.
+            return Interlocked.Increment(ref objsInUse);
+        }
+
+        // This method performs a thread-safe decrementation the objects count.
+        public static int UncountObject()
+        {
+            // Decrement the global count of objects.
+            return Interlocked.Decrement(ref objsInUse);
+        }
+
+        // Returns the current server lock count.
+        public static int ServerLockCount
+        {
+            get
+            {
+                lock (lockObject)
+                {
+                    return serverLocks;
+                }
+            }
+        }
+
+        // This method performs a thread-safe incrementation the 
+        // server lock count.
+        public static int CountLock()
+        {
+            // Increment the global lock count of this server.
+            return Interlocked.Increment(ref serverLocks);
+        }
+
+        // This method performs a thread-safe decrementation the 
+        // server lock count.
+        public static int UncountLock()
+        {
+            // Decrement the global lock count of this server.
+            return Interlocked.Decrement(ref serverLocks);
+        }
+
+        // AttemptToTerminateServer() will check to see if the objects count and the server 
+        // lock count have both dropped to zero.
+        //
+        // If so, and if we were started by COM, we post a WM_QUIT message to the main thread's
+        // message loop. This will cause the message loop to exit and hence the termination 
+        // of this application. If hand-started, then just trace that it WOULD exit now.
+        //
+        public static void ExitIf()
+        {
+            lock (lockObject)
+            {
+                if ((ObjectsCount <= 0) && (ServerLockCount <= 0))
+                {
+                    if (StartedByCOM)
+                    {
+                        UIntPtr wParam = new UIntPtr(0);
+                        IntPtr lParam = new IntPtr(0);
+                        PostThreadMessage(MainThreadId, 0x0012, wParam, lParam);
+                    }
+                }
+            }
+        }
+        #endregion
+
+        // -----------------
+        // PRIVATE FUNCTIONS
+        // -----------------
+
+        #region Dynamic Driver Assembly Loader
+        //
+        // Load the assemblies that contain the classes that we will serve
+        // via COM. These will be located in the same folder as
+        // our executable.
+        //
+        private static bool LoadComObjectAssemblies()
+        {
+            s_ComObjectAssys = new ArrayList();
+            s_ComObjectTypes = new ArrayList();
+
+            // put everything into one folder, the same as the server.
+            string assyPath = Assembly.GetEntryAssembly().Location;
+            assyPath = Path.GetDirectoryName(assyPath);
+
+            DirectoryInfo d = new DirectoryInfo(assyPath);
+            foreach (FileInfo fi in d.GetFiles("*.dll"))
+            {
+                string aPath = fi.FullName;
+                //
+                // First try to load the assembly and get the types for
+                // the class and the class factory. If this doesn't work ????
+                //
+                try
+                {
+                    Assembly so = Assembly.LoadFrom(aPath);
+                    //PWGS Get the types in the assembly
+                    Type[] types = so.GetTypes();
+                    foreach (Type type in types)
+                    {
+                        // PWGS Now checks the type rather than the assembly
+                        // Check to see if the type has the ServedClassName attribute, only use it if it does.
+                        MemberInfo info = type;
+
+                        object[] attrbutes = info.GetCustomAttributes(typeof(ServedClassNameAttribute), false);
+                        if (attrbutes.Length > 0)
+                        {
+                            //MessageBox.Show("Adding Type: " + type.Name + " " + type.FullName);
+                            s_ComObjectTypes.Add(type); //PWGS - much simpler
+                            s_ComObjectAssys.Add(so);
+                        }
+                    }
+                }
+                catch (BadImageFormatException)
+                {
+                    // Probably an attempt to load a Win32 DLL (i.e. not a .net assembly)
+                    // Just swallow the exception and continue to the next item.
+                    continue;
+                }
+                catch (Exception e)
+                {
+                    MessageBox.Show("Failed to load served COM class assembly " + fi.Name + " - " + e.Message,
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    return false;
+                }
+
+            }
+            return true;
+        }
+        #endregion
+
+        #region COM Registration and Unregistration
+        //
+        // Test if running elevated
+        //
+        private static bool IsAdministrator
+        {
+            get
+            {
+                WindowsIdentity i = WindowsIdentity.GetCurrent();
+                WindowsPrincipal p = new WindowsPrincipal(i);
+                return p.IsInRole(WindowsBuiltInRole.Administrator);
+            }
+        }
+
+        //
+        // Elevate by re-running ourselves with elevation dialog
+        //
+        private static void ElevateSelf(string arg)
+        {
+            ProcessStartInfo si = new ProcessStartInfo();
+            si.Arguments = arg;
+            si.WorkingDirectory = Environment.CurrentDirectory;
+            si.FileName = Application.ExecutablePath;
+            si.Verb = "runas";
+            try { Process.Start(si); }
+            catch (System.ComponentModel.Win32Exception)
+            {
+                MessageBox.Show("The Meade.net was not " + (arg == "/register" ? "registered" : "unregistered") +
+                    " because you did not allow it.", "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(ex.ToString(), "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+            }
+            return;
+        }
+
+        //
+        // Do everything to register this for COM. Never use REGASM on
+        // this exe assembly! It would create InProcServer32 entries 
+        // which would prevent proper activation!
+        //
+        // Using the list of COM object types generated during dynamic
+        // assembly loading, it registers each one for COM as served by our
+        // exe/local server, as well as registering it for ASCOM. It also
+        // adds DCOM info for the local server itself, so it can be activated
+        // via an outboiud connection from TheSky.
+        //
+        private static void RegisterObjects()
+        {
+            if (!IsAdministrator)
+            {
+                ElevateSelf("/register");
+                return;
+            }
+            //
+            // If reached here, we're running elevated
+            //
+
+            Assembly assy = Assembly.GetExecutingAssembly();
+            Attribute attr = Attribute.GetCustomAttribute(assy, typeof(AssemblyTitleAttribute));
+            string assyTitle = ((AssemblyTitleAttribute)attr).Title;
+            attr = Attribute.GetCustomAttribute(assy, typeof(AssemblyDescriptionAttribute));
+            string assyDescription = ((AssemblyDescriptionAttribute)attr).Description;
+
+            //
+            // Local server's DCOM/AppID information
+            //
+            try
+            {
+                //
+                // HKCR\APPID\appid
+                //
+                using (RegistryKey key = Registry.ClassesRoot.CreateSubKey("APPID\\" + s_appId))
+                {
+                    key.SetValue(null, assyDescription);
+                    key.SetValue("AppID", s_appId);
+                    key.SetValue("AuthenticationLevel", 1, RegistryValueKind.DWord);
+                }
+                //
+                // HKCR\APPID\exename.ext
+                //
+                using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(string.Format("APPID\\{0}",
+                            Application.ExecutablePath.Substring(Application.ExecutablePath.LastIndexOf('\\') + 1))))
+                {
+                    key.SetValue("AppID", s_appId);
+                }
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show("Error while registering the server:\n" + ex.ToString(),
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                return;
+            }
+            finally
+            {
+            }
+
+            //
+            // For each of the driver assemblies
+            //
+            foreach (Type type in s_ComObjectTypes)
+            {
+                bool bFail = false;
+                try
+                {
+                    //
+                    // HKCR\CLSID\clsid
+                    //
+                    string clsid = Marshal.GenerateGuidForType(type).ToString("B");
+                    string progid = Marshal.GenerateProgIdForType(type);
+                    //PWGS Generate device type from the Class name
+                    string deviceType = type.Name;
+
+                    using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(string.Format("CLSID\\{0}", clsid)))
+                    {
+                        key.SetValue(null, progid);						// Could be assyTitle/Desc??, but .NET components show ProgId here
+                        key.SetValue("AppId", s_appId);
+                        using (RegistryKey key2 = key.CreateSubKey("Implemented Categories"))
+                        {
+                            key2.CreateSubKey("{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}");
+                        }
+                        using (RegistryKey key2 = key.CreateSubKey("ProgId"))
+                        {
+                            key2.SetValue(null, progid);
+                        }
+                        key.CreateSubKey("Programmable");
+                        using (RegistryKey key2 = key.CreateSubKey("LocalServer32"))
+                        {
+                            key2.SetValue(null, Application.ExecutablePath);
+                        }
+                    }
+                    //
+                    // HKCR\CLSID\progid
+                    //
+                    using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(progid))
+                    {
+                        key.SetValue(null, assyTitle);
+                        using (RegistryKey key2 = key.CreateSubKey("CLSID"))
+                        {
+                            key2.SetValue(null, clsid);
+                        }
+                    }
+                    //
+                    // ASCOM 
+                    //
+                    assy = type.Assembly;
+
+                    // Pull the display name from the ServedClassName attribute.
+                    attr = Attribute.GetCustomAttribute(type, typeof(ServedClassNameAttribute)); //PWGS Changed to search type for attribute rather than assembly
+                    string chooserName = ((ServedClassNameAttribute)attr).DisplayName ?? "MultiServer";
+                    using (var P = new ASCOM.Utilities.Profile())
+                    {
+                        P.DeviceType = deviceType;
+                        P.Register(progid, chooserName);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    MessageBox.Show("Error while registering the server:\n" + ex.ToString(),
+                            "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    bFail = true;
+                }
+                finally
+                {
+                }
+                if (bFail) break;
+            }
+        }
+
+        //
+        // Remove all traces of this from the registry. 
+        //
+        // **TODO** If the above does AppID/DCOM stuff, this would have
+        // to remove that stuff too.
+        //
+        private static void UnregisterObjects()
+        {
+            if (!IsAdministrator)
+            {
+                ElevateSelf("/unregister");
+                return;
+            }
+
+            //
+            // Local server's DCOM/AppID information
+            //
+            Registry.ClassesRoot.DeleteSubKey(string.Format("APPID\\{0}", s_appId), false);
+            Registry.ClassesRoot.DeleteSubKey(string.Format("APPID\\{0}",
+                    Application.ExecutablePath.Substring(Application.ExecutablePath.LastIndexOf('\\') + 1)), false);
+
+            //
+            // For each of the driver assemblies
+            //
+            foreach (Type type in s_ComObjectTypes)
+            {
+                string clsid = Marshal.GenerateGuidForType(type).ToString("B");
+                string progid = Marshal.GenerateProgIdForType(type);
+                string deviceType = type.Name;
+                //
+                // Best efforts
+                //
+                //
+                // HKCR\progid
+                //
+                Registry.ClassesRoot.DeleteSubKey(String.Format("{0}\\CLSID", progid), false);
+                Registry.ClassesRoot.DeleteSubKey(progid, false);
+                //
+                // HKCR\CLSID\clsid
+                //
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Implemented Categories\\{{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}}", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Implemented Categories", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\ProgId", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\LocalServer32", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Programmable", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}", clsid), false);
+                try
+                {
+                    //
+                    // ASCOM
+                    //
+                    using (var P = new ASCOM.Utilities.Profile())
+                    {
+                        P.DeviceType = deviceType;
+                        P.Unregister(progid);
+                    }
+                }
+                catch (Exception) { }
+            }
+        }
+        #endregion
+
+        #region Class Factory Support
+        //
+        // On startup, we register the class factories of the COM objects
+        // that we serve. This requires the class facgtory name to be
+        // equal to the served class name + "ClassFactory".
+        //
+        private static bool RegisterClassFactories()
+        {
+            s_ClassFactories = new ArrayList();
+            foreach (Type type in s_ComObjectTypes)
+            {
+                ClassFactory factory = new ClassFactory(type);                  // Use default context & flags
+                s_ClassFactories.Add(factory);
+                if (!factory.RegisterClassObject())
+                {
+                    MessageBox.Show("Failed to register class factory for " + type.Name,
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    return false;
+                }
+            }
+            ClassFactory.ResumeClassObjects();                                  // Served objects now go live
+            return true;
+        }
+
+        private static void RevokeClassFactories()
+        {
+            ClassFactory.SuspendClassObjects();                                 // Prevent race conditions
+            foreach (ClassFactory factory in s_ClassFactories)
+                factory.RevokeClassObject();
+        }
+        #endregion
+
+        #region Command Line Arguments
+        //
+        // ProcessArguments() will process the command-line arguments
+        // If the return value is true, we carry on and start this application.
+        // If the return value is false, we terminate this application immediately.
+        //
+        private static bool ProcessArguments(string[] args)
+        {
+            bool bRet = true;
+
+            //
+            //**TODO** -Embedding is "ActiveX start". Prohibit non_AX starting?
+            //
+            if (args.Length > 0)
+            {
+
+                switch (args[0].ToLower())
+                {
+                    case "-embedding":
+                        StartedByCOM = true;                                        // Indicate COM started us
+                        break;
+
+                    case "-register":
+                    case @"/register":
+                    case "-regserver":                                          // Emulate VB6
+                    case @"/regserver":
+                        RegisterObjects();                                      // Register each served object
+                        bRet = false;
+                        break;
+
+                    case "-unregister":
+                    case @"/unregister":
+                    case "-unregserver":                                        // Emulate VB6
+                    case @"/unregserver":
+                        UnregisterObjects();                                    //Unregister each served object
+                        bRet = false;
+                        break;
+
+                    default:
+                        MessageBox.Show("Unknown argument: " + args[0] + "\nValid are : -register, -unregister and -embedding",
+                            "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+                        break;
+                }
+            }
+            else
+                StartedByCOM = false;
+
+            return bRet;
+        }
+        #endregion
+
+        #region SERVER ENTRY POINT (main)
+        //
+        // ==================
+        // SERVER ENTRY POINT
+        // ==================
+        //
+        [STAThread]
+        static void Main(string[] args)
+        {
+            if (!LoadComObjectAssemblies()) return;                     // Load served COM class assemblies, get types
+
+            if (!ProcessArguments(args)) return;                        // Register/Unregister
+
+            // Initialize critical member variables.
+            objsInUse = 0;
+            serverLocks = 0;
+            MainThreadId = GetCurrentThreadId();
+            Thread.CurrentThread.Name = "Main Thread";
+
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            s_MainForm = new frmMain();
+            if (StartedByCOM) s_MainForm.WindowState = FormWindowState.Minimized;
+
+            // Register the class factories of the served objects
+            RegisterClassFactories();
+
+            // Start up the garbage collection thread.
+            GarbageCollection GarbageCollector = new GarbageCollection(1000);
+            Thread GCThread = new Thread(new ThreadStart(GarbageCollector.GCWatch));
+            GCThread.Name = "Garbage Collection Thread";
+            GCThread.Start();
+
+            //
+            // Start the message loop. This serializes incoming calls to our
+            // served COM objects, making this act like the VB6 equivalent!
+            //
+            try
+            {
+                Application.Run(s_MainForm);
+            }
+            finally
+            {
+                // Revoke the class factories immediately.
+                // Don't wait until the thread has stopped before
+                // we perform revocation!!!
+                RevokeClassFactories();
+
+                // Now stop the Garbage Collector thread.
+                GarbageCollector.StopThread();
+                GarbageCollector.WaitForThreadToStop();
+            }
+        }
+        #endregion
+    }
+}

Meade.net/Localization/LocalisationHelper.cs

@@ -0,0 +1,36 @@
+using System.Globalization;
+using System.Threading;
+using System.Resources;
+using System.Reflection;
+
+namespace ASCOM.Meade.net.Localization
+{
+    internal class LocalisationHelper
+    {
+        private const string LocalizationNamespace = "LocalisationTest.Localization.Resources.Localization";
+        ResourceManager _resourceManager;
+
+        public LocalisationHelper()
+        {
+            _resourceManager = new ResourceManager(LocalizationNamespace, Assembly.GetExecutingAssembly());
+
+            SetLocalisation(CultureInfo.CurrentCulture.Name);
+        }
+
+        internal void SetLocalisation(string name)
+        {
+            var cultureInfo = new CultureInfo(name);
+
+            CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
+            CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
+
+            Thread.CurrentThread.CurrentCulture = cultureInfo;
+            Thread.CurrentThread.CurrentUICulture = cultureInfo;
+        }
+
+        internal string GetString(string key)
+        {
+            return _resourceManager.GetString(key);
+        }
+    }
+}

Meade.net/Meade.net.csproj

@@ -0,0 +1,174 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3689A2CB-94C5-4012-A5CF-7E7D1DD27143}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ASCOM.Meade.net</RootNamespace>
+    <AssemblyName>ASCOM.Meade.net.Server</AssemblyName>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>2.0</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <TargetFrameworkProfile />
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x86</PlatformTarget>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>LocalServer.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>ASCOM.ico</ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>..\bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ASCOM.Attributes, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.DeviceInterfaces, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Exceptions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Utilities, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ClassFactory.cs" />
+    <Compile Include="frmMain.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="frmMain.Designer.cs">
+      <DependentUpon>frmMain.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GarbageCollection.cs" />
+    <Compile Include="Localization\LocalisationHelper.cs" />
+    <Compile Include="LocalServer.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <EmbeddedResource Include="frmMain.resx">
+      <SubType>Designer</SubType>
+      <DependentUpon>frmMain.cs</DependentUpon>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="ReferenceCountedObject.cs" />
+    <Compile Include="SetupDialogForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="SetupDialogForm.designer.cs">
+      <DependentUpon>SetupDialogForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="SharedResources.cs" />
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="SetupDialogForm.resx">
+      <DependentUpon>SetupDialogForm.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="ASCOM.ico" />
+    <Content Include="ASCOM.png" />
+    <Content Include="ReadMe.htm" />
+    <None Include="Resources\ASCOM.bmp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="LocalServer.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+</Project>

Meade.net/Properties/AssemblyInfo.cs

@@ -0,0 +1,27 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+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("ASCOM Meade.net server")]
+[assembly: AssemblyDescription("ASCOM multi-interface server for Meade.net")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("cjdawson.com")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Copyright © 2019 cjdawson.com")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.5.0.0")]
+[assembly: AssemblyFileVersion("0.5.0.0")]
+
+[assembly: ComVisibleAttribute(false)]

Meade.net/Properties/Resources.Designer.cs

@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace ASCOM.Meade.net.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ASCOM.Meade.net.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap ASCOM {
+            get {
+                object obj = ResourceManager.GetObject("ASCOM", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+    }
+}

Meade.net/Properties/Resources.resx

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="ASCOM" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\ASCOM.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+</root>

Meade.net/ReadMe.htm

@@ -0,0 +1,666 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+  <HEAD>
+    <META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252"/>
+    <TITLE>Untitled Document</TITLE>
+    <META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2  (Win32)"/>
+    <META NAME="CREATED" CONTENT="0;0"/>
+    <META NAME="CHANGEDBY" CONTENT="Chris Rowland"/>
+    <META NAME="CHANGED" CONTENT="20110422;10442800"/>
+    <META NAME="CHANGEDBY" CONTENT="Chris Rowland"/>
+    <STYLE TYPE="text/css">
+      <!--
+		@page { margin: 2cm }
+		P { font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal }
+		TD P { font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal }
+		H3 { font-family: "Arial", "Helvetica", sans-serif }
+		H2 { font-family: "Arial", "Helvetica", sans-serif }
+		H4 { font-family: "Arial", "Helvetica", sans-serif }
+		PRE { margin-left: 0.18cm; margin-right: 0.18cm; margin-top: 0.18cm; margin-bottom: 0.18cm; background: #ccffff }
+		PRE.western { font-weight: normal }
+		PRE.cjk { font-family: "NSimSun", monospace; font-weight: normal }
+		PRE.ctl { font-weight: normal }
+		EM.underline { text-decoration: underline }
+	-->
+    </STYLE>
+  </HEAD>
+  <BODY LANG="en-GB" DIR="LTR">
+    <TABLE WIDTH="100%" BORDER="0" CELLPADDING="4" CELLSPACING="0" STYLE="page-break-before: always">
+      <TR>
+        <TD>
+          <H2>
+            ASCOM LocalServer (singleton) Host
+          </H2>
+        </TD>
+      </TR>
+    </TABLE>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+    <H4>
+      You have just created a local server (singleton) host for one or
+      more ASCOM driver classes.
+    </H4>
+    <HR/>
+    <P>
+      This project implements an ASCOM host server for one or more
+      driver classes in a single-instance executable. It can be used to
+      serve multiple instances of a single driver class (hub), provide
+      driver services for multiple devices (e.g., Telescope and Focuser) to
+      multiple applications and allow multiple devices of the same type to
+      be connected. In the latter scenario, the multiple driver classes
+      will often share one or more resources such as the serial connection
+      and a microcontroller in the combined device. From the client's
+      perspective, using the drivers served by the local server is exactly
+      the same as if the drivers are loaded into the client's process space
+      (in-proc servers).
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <STRONG>
+        <SPAN STYLE="background: #ffee88">NOTE:</SPAN>
+      </STRONG>
+      <SPAN STYLE="background: #ffee88">
+        Unless you are prepared to handle all of the timing issues that arise
+        when multiple clients are accessing the properties and methods of
+        your driver(s), stop now. Just because the local server serializes
+        the calls to your driver(s)' properties and methods does not mean
+        that there will be no timing or concurrency issues.<BR/>
+        &nbsp;<BR/>For
+        example, suppose the hub serves instances of a Telescope driver. One
+        client sets the TargetRightAscension property, then another sets
+        TargetRightAscension to a different value, then the first client sets
+        TargetDeclination, then the first client calls SlewToTarget()
+        followed by the second client calling SlewToTarget(). Besides the
+        first client's slew command sending the scope to the wrong (and
+        possibly dangerous) coordinates, there is the problem of the second
+        client trying to slew a slewing scope. Local server drivers are
+        tricky to get right. There is no such thing as &quot;ignorance is
+        bliss&quot; here.
+
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        This implementation has changed
+        from what was defined for Platform 5.5 as follows:
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        The drivers are now installed in
+        the same folder as the local server executable. This makes deployment
+        cleaner because the whole driver can exist in a single folder
+        independently of other drivers.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        The ProgId and friendly name as
+        displayed by the Chooser are defined using attributes. This allows
+        driver dlls to be identified clearly and so avoids confusion with
+        other dlls that may be required such as interop dlls.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        Some changes have been made that
+        will facilitate generating multiple drivers of the same type.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        I've put some additional advice and
+        comments in the notes below <I>in italics.</I>
+      </SPAN>
+    </P>
+    <P>
+      You're probably anxious to get going, but you really should read
+      through the <A HREF="#theory">Theory of Operation</A> and <A HREF="#details">
+        Detailed
+        Use and Deployment
+      </A> below.
+    </P>
+    <P>You must do the following in order to complete your local server:</P>
+    <OL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          In the local server's project
+          properties, Application tab, change BOTH the AssemblyName and the
+          default assembly name to ASCOM.xxx (e.g., ASCOM.SuperScope). <I>
+            This
+            may be done by default now.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Add one or more driver skeleton
+          projects using the in-proc templates. You may use either the C# or
+          VB templates. Project name is not important (not used in ProgID)
+          choose something like TelescopeDriver. You will be changing the
+          substituted project name in these projects below. If you ensure that
+          the LocalServer and all the driver projects have the same NameSpace
+          e.g. ASCOM.SuperScope the renaming in section 6a will not be
+          required.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Develop and debug these driver
+          projects as normal in-process assemblies. This will be much simpler
+          because the driver and test code can be debugged in the same
+          process.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Build the LocalServer.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Set a reference to the local
+          server <STRONG>project</STRONG> in each of the driver skeleton
+          projects.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">In each skeleton driver project:</P>
+        <OL TYPE="a">
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              Do a Find In Files for the
+              project name of the skeleton driver (e.g., TelescopeDriver) and
+              change it to match the project name of your local server (e.g.
+              SuperScope). You don't have to do this in the ReadMe.html file.
+              Everywhere else, however, is IMPORTANT. This sets the correct
+              namespace, progID, etc. If you're a bit more brave, you can use
+              Replace in Files. <I>
+                This may not be needed if the correct
+                namespace and naming conventions have been followed when the
+                drivers and local server were generated.
+              </I>
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties,
+              Application tab, change the assembly name to
+              ASCOM.<EM CLASS="underline">localserverprojectname</EM>.<EM>drivertype</EM>,
+              (e.g., ASCOM.SuperScope.Telescope).
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties,
+              Application tab, click Assembly Information...
+            </P>
+            <UL>
+              <LI>
+                <P STYLE="margin-bottom: 0cm">
+                  Assure that Make assembly COM
+                  visible is <STRONG>on</STRONG> (it should already be on).
+                </P>
+              </LI>
+              <LI>
+                <P STYLE="margin-bottom: 0cm">
+                  Edit the Product Name to be the
+                  &quot;friendly name&quot; of your driver as will be shown in the
+                  Chooser. <I>
+                    Not used now, use the ServedClassName attribute
+                    instead.
+                  </I>
+                </P>
+              </LI>
+            </UL>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties, Build tab,
+              turn <STRONG>off</STRONG> Register for COM Interop.
+            </P>
+          </LI>
+          <LI>
+            <P>
+              Modify the driver class declaration to inherit from
+              ReferenceCountedObjectBase. Examples:<BR/>C#:
+            </P>
+            <PRE CLASS="western">
+              public class Telescope :
+              ReferenceCountedObjectBase,
+              ITelescope
+            </PRE>
+            <P>
+              VB:
+            </P>
+            <PRE CLASS="western">
+              Public Class Telescope
+              '==================================
+              Inherits ReferenceCountedObjectBase
+              Implements ITelescope
+              '==================================
+            </PRE>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In driver.cs/driver.vb, remove
+              the entire ASCOM Registration region
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In driver.cs/driver.vb, remove
+              the private strings for driver ID and driver description. <I>
+                They
+                may be needed internally, and if so should be set from the
+                associated attributes, ServedClassName for the description and
+                ProgId for the driver Id.
+              </I>
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              Modify the class attributes by
+              adding the ServedClassName and ProgID attributes. The
+              ServedClassName attribute must be the friendly name shown as the
+              device name in the Chooser and the ProgId the progid of the driver
+              e.g. ASCOM.SuperScope.Telescope. The class header should look like
+              this:
+            </P>
+            <P STYLE="margin-bottom: 0cm">C#:</P>
+            <PRE CLASS="western" STYLE="margin-right: 0.16cm">
+              <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+                [<FONT COLOR="#2b91af">Guid</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#a31515">&quot;0AE8B38D-10A1-4A8D-A5B7-1B050F74B48B&quot;</FONT><FONT COLOR="#000000">)]  // set by the template</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ProgId</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#a31515">&quot;ASCOM.SuperScope.Telescope&quot;</FONT><FONT COLOR="#000000">)]</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ServedClassName</FONT><FONT COLOR="#000000"> (</FONT><FONT COLOR="#a31515">&quot;Super Scope Telescope&quot;</FONT><FONT COLOR="#000000">)]</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ClassInterface</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#2b91af">ClassInterfaceType</FONT><FONT COLOR="#000000">.None)]</FONT>
+                <FONT COLOR="#0000ff">public </FONT><FONT COLOR="#0000ff">class </FONT><FONT COLOR="#2b91af">Telescope </FONT><FONT COLOR="#000000">: </FONT><FONT COLOR="#2b91af">ReferenceCountedObjectBase</FONT><FONT COLOR="#000000"> , </FONT><FONT COLOR="#2b91af">ITelescope</FONT>
+              </FONT>
+            </PRE>
+          </LI>
+        </OL>
+      </LI>
+    </OL>
+    <P STYLE="margin-bottom: 0cm">
+      <BR/>
+    </P>
+    <OL>
+      <OL TYPE="a">
+        <P>VB:</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            &lt;Guid(&ldquo;<FONT COLOR="#a31515">0AE8B38D-10A1-4A8D-A5B7-1B050F74B48B</FONT>&rdquo;)&gt;
+            &lt;ProgId(&ldquo;ASCOM.SuperScope.Telescope&rdquo;)&gt;
+            &lt;ServedClassName(&ldquo;Super Scope Telescope&rdquo;)&gt;
+            Public Class Telescope
+            '==================================
+            Inherits ReferenceCountedObjectBase
+            Implements ITelescope
+            '==================================
+          </FONT>
+        </PRE>
+      </OL>
+    </OL>
+    <P STYLE="margin-left: 2.5cm">
+      Add the following line to the driver
+      constructor, this sets the driver ID using the ProgId Attribute:
+    </P>
+    <OL>
+      <OL TYPE="a">
+        <P>C#</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            s_csDriverID = <FONT COLOR="#2b91af">Marshal</FONT><FONT COLOR="#000000">.GenerateProgIdForType(</FONT><FONT COLOR="#0000ff">this</FONT><FONT COLOR="#000000">.GetType());</FONT>
+          </FONT>
+        </PRE>
+        <P>VB:</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            s_csDriverID = <FONT COLOR="#2b91af">Marshal</FONT><FONT COLOR="#000000">.GenerateProgIdForType(</FONT><FONT COLOR="#0000ff">Me</FONT><FONT COLOR="#000000">.GetType())</FONT>
+          </FONT>
+        </PRE>
+      </OL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Unless you're writing a
+          single-driver hub, you will have two or more driver types (e.g.
+          Telescope and Focuser) and thus two or more driver assembly projects
+          added. Presumably, these drivers need to share some resources (e.g.
+          a single COM port via Helper.Serial). <U>
+            Put shared resources into
+            the SharedResources class provided
+          </U>. There are some examples that
+          should give a clue, modify and delete these as required.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          A shared serial port is already
+          provided (see SharedResources.cs) as <FONT FACE="Lucida Console, Courier New, Courier, monospace">SharedResources.SharedSerial</FONT>
+          and it is an ASCOM Helper Serial object. You may wish to define
+          additional shared resources in static member variables with public
+          static accessor properties as is already done for SharedSerial.
+          Unfortunately, if you are a Visual Basic programmer, you will have
+          to make these additions in C#.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          If you are writing a hub and don't
+          need the serial port, in SharedResources.cs you can remove the
+          public static SharedSerial property, the m_SharedSerial member in
+          the private data region, and the line in main that initializes it.
+          If you don't need any other shared resources for your hub, then you
+          can remove the SharedResources.cs file completely.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          If you modified the LocalServer,
+          build it again now. This will refresh the stuff that's visible to
+          the drivers.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Build the driver skeletons to
+          verify that you got all of the namespace and other variable changes.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The local server dynamically loads the driver assemblies from
+          the same folder as the local server executable. <BR/>
+          <BR/>During
+          development, you'll need to add a post-build task to each of your
+          driver assembly projects which puts a copy of the driver assembly
+          into the local server executable folder. Here is an example:
+        </P>
+        <PRE CLASS="western">    copy &quot;$(TargetPath)&quot; &quot;$(SolutionDir)\SuperScope\$(OutDir)\$(TargetFileName)&quot;</PRE>
+        <P STYLE="margin-bottom: 0cm">
+          This assumes that the server project is called &ldquo;SuperScope&rdquo;,
+          and handles using the debug or release build.<BR/>
+          Note the quotes for
+          possible path elements with spaces in them. <I>
+            An alternative is to
+            set the build path to the required destination instead of the
+            default path.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          <I>
+            Make sure the drivers are
+            registered through the local server by running it with the /register
+            parameter, see below for details.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          <SPAN STYLE="background: #ffff00">IMPORTANT:</SPAN>
+          With a local server based driver (or hub) it is possible for
+          multiple clients to control the device(s). It is up to you to
+          safeguard against abuse. <I>
+            The sort of thing that's needed is to
+            have a counter of the number of connections to a device, the
+            connection is only fully broken when the number of connections is
+            zero. You may also need code to prevent several drivers from talking
+            to the hardware at the same time, the lock pattern is useful for
+            that.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P>
+          You may want to add controls and/or status information to the
+          main form frmMain of the local server. Please resist the temptation
+          to turn the local server's main form into a graphical device control
+          panel. Instead, make a separate application that uses the served
+          driver(s). <U>A driver is not a program!</U>
+        </P>
+      </LI>
+    </OL>
+    <H3>Notes</H3>
+    <UL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          The local server handles all of
+          the registration and unregistration for each of its served driver
+          classes, including the ASCOM Chooser info and the DCOM/AppID info
+          needed for activation from TheSky. By running the server from a
+          command line and giving /register or /unregister as the command line
+          option, it will register or unregister all served classes
+          (respectively). <SPAN STYLE="background: #ffff00">
+            Never use REGASM
+            on the local server executable!
+          </SPAN> <I>
+            This can be done in the
+            Visual Studio IDE by setting the server project to run as startup
+            and setting the command line argument to /register in Debug &ndash;
+            Start Options.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          When you make the installer for
+          your local server based driver/hub, do not let it register the
+          executable for COM. Instead, have it activate the installed local
+          server with the /register option.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The ASCOM registration uses the ServedClassName attribute as
+          the friendly name that will show in the chooser and the ProgId
+          attribute as the driver Id.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The best deployment way is to install all the files in a
+          folder that's a sub folder of the main driver, so the SuperScope
+          driver files will be in the folder ...\ASCOM\Telescope\SuperScope.
+          This can be done in the Inno script by changing the DefaultDirName
+          like this:<BR/>
+            DefaultDirName=&quot;{cf}\ASCOM\Telescope\SuperScope&quot;<BR/>then
+	the files can all be installed with DestDir: {app}; 
+        </P>
+      </LI>
+    </UL>
+    <H3>
+      <A NAME="theory"></A>Theory of Operation
+    </H3>
+    <P>
+      The local server is an executable which can provide multiple
+      instances of multiple drivers to multiple clients. This capability is
+      needed for two applications:
+    </P>
+    <UL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          A hub, which allows multiple
+          clients to share a single device
+        </P>
+      </LI>
+      <LI>
+        <P>
+          A device which provides multiple services, such as a
+          telescope which has a focuser built-in where both the telescope and
+          focuser are controlled by the same serial connection and different
+          client programs need to control to the focuser and telescope.
+        </P>
+      </LI>
+    </UL>
+    <P>
+      By simply dropping suitably developed driver assemblies into the
+      same folder as the local server executable, the local server will
+      find them and register them for COM and ASCOM and serve any number of
+      instances of the drivers' interfaces to any number of client
+      programs. It does this by locating and loading the driver assemblies,
+      analysing them to detect their classes and interfaces, and
+      implementing a class factory that can create instances of them for
+      clients.
+    </P>
+    <P>
+      A driver is an assembly which contains a class that <EM>implements</EM>
+      one of the ASCOM standard driver interfaces and <EM>inherits</EM> the
+      ReferenceCountedObjectBase class of the local server. Apart from
+      that, driver assemblies are identical to those that are used
+      in-process (DLL-type). The instructions above detail the steps needed
+      to convert an in-process driver into one that can be served by the
+      local server.
+    </P>
+    <P>
+      The name of the local server is important, so we provide it as a
+      <EM>template</EM> from which you can create a local server for your
+      produce. To make this clear, let's assume that your company AlphaTech
+      produces a telescope system which contains a microcontroller that is
+      able to control not only the telescope mount, but also a focuser and
+      a camera rotator. The mount, focuser, and rotator are all controlled
+      via commands sent through a common serial line connecting the
+      computer to the microcontroller, so you need a local server. In
+      ASCOM, then, you probably want your system to appear as
+      AlphaTech.Telescope, AlphaTech.Focuser, and AlphaTech.Rotator. Then
+      you would name the local server AlphaTech. Be sure to give this due
+      consideration before creating the template, the project name is the
+      name of your local server. <I>
+        Is this still correct? I get the
+        impression that ASCOM.AlphaTech.Server would be OK.
+      </I>
+    </P>
+    <P>
+      The fact that driver classes inherit from the local server's
+      ReferenceCountedObjectBase class allows the local server to maintain
+      a reference count on the driver class. If a client creates an
+      instance of a served driver, the local server automatically starts up
+      and provides an instance of the class to the client. Once started the
+      local server can provide additional instances of any of its served
+      driver classes. If the reference count of all served classes drops to
+      zero as a result of clients releasing their instances, the local
+      server will automatically exit.
+    </P>
+    <P>
+      Registration services provided include not only the basic COM
+      class registration, but also DCOM/AppID info needed to use the served
+      classes from outbound connections from Software Bisque's TheSky. It
+      also registers the served classes for the ASCOM Chooser. The
+      &quot;friendly&quot; name of each served driver that appears in the
+      chooser comes from the driver's ServedClassName attribute. This also
+      used to identify a driver so that non driver dlls, such as Interop
+      dlls can be ignored. The COM ProgID for each served driver is
+      specified in the ProgId attribute - ASCOM.<EM>localservername</EM>.<EM>drivertype</EM>,
+      for example, ASCOM.AlphaTech.Telescope, where AlphaTech is the local
+      server name and Telescope is the type of the driver. Unregistering
+      removes all of this information from the system. Specifying the
+      ProgId as an attribute allows multiple driver assemblies to be
+      generated using the same source and namespace. This is used to
+      provide multiple instances of the same driver, each with a different
+      ProgId and so able to be registered separately.
+    </P>
+    <P>
+      Driver DLLs are identified for registering/unregistering because
+      they contain a type with the ServedClassName attribute. Only these
+      will be registered for Com and ASCOM.  This has changed; in Platform
+      5 there was no attribute and the local server attempted to register
+      all dlls. The new behaviour allows support dlls such as interop dlls
+      to be included without them being registered incorrectly.  There was
+      also an interim version where the ServedClassName attribute was on
+      the assembly, not the class.  <I>
+        All these previous versions, and the
+        new drivers will operate together with Platform 6, the changes are
+        local to the individual drivers.
+      </I>
+    </P>
+    <H3>
+      <A NAME="details"></A>Detailed Use and Deployment
+    </H3>
+    <P>
+      Once you have built your local server and the served driver class
+      assemblies, here's how to use it. To register the served classes,
+      activate the local server from a shell command line with the option
+      /register (or /regserver, for VB6 compatibility):
+    </P>
+    <PRE CLASS="western">
+      C:\xxx&gt; <EM>localserver</EM>.exe /register
+    </PRE>
+    <P>
+      To unregister the local server and its drivers, activate the local
+      server from a shell command line with the option /unregister (or
+      /unregserver for VB6 compatibility):
+    </P>
+    <PRE CLASS="western">
+      C:\xxx&gt; <EM>localserver</EM>.exe /unregister
+    </PRE>
+    <P>
+      When the operating system starts the local server in response to a
+      client creating one of it's served driver classes, the command option
+      /embedding is included. The local server's code detects this and sets
+      a variable that you can use.
+    </P>
+    <P STYLE="margin-bottom: 0cm">
+      When deploying a hub or set of drivers
+      with the local server, you'll have to arrange for the local server
+      and the driver assemblies to be placed together in a folder in the
+      ASCOM driver folder. Any support files, such as Interop DLLs can be
+      put in the same fiolder. That's all you need to do, the local server
+      will find them in the same folder as it is located in.
+    </P>
+    <DIV ALIGN="RIGHT">
+      <TABLE WIDTH="100"% BORDER="0" CELLPADDING="4" CELLSPACING="0">
+        <TR>
+          <TD>
+            <TABLE WIDTH="100"% BORDER="0" CELLPADDING="4" CELLSPACING="0">
+              <TR>
+                <TD>
+                  <H3>ASCOM Initiative</H3>
+                </TD>
+                <TD>
+                  <IMG SRC="ASCOM.png" NAME="graphics1" ALIGN="RIGHT" WIDTH="48" HEIGHT="56" BORDER="0"/>
+                </TD>
+              </TR>
+            </TABLE>
+            <P>
+              <BR/>
+              <BR/>
+
+            </P>
+          </TD>
+        </TR>
+        <TR>
+          <TD>
+            <P>
+              The ASCOM Initiative consists of a group of astronomy software
+              developers and instrument vendors whose goals are to promote the
+              driver/client model and scripting automation.
+            </P>
+            <P>
+              See the <A HREF="http://ascom-standards.org/" TARGET="browser">
+                ASCOM
+                web site
+              </A> for more information. Please participate in the
+              <A HREF="http://tech.groups.yahoo.com/group/ASCOM-Talk" TARGET="browser">
+                ASCOM-Talk
+                Yahoo Group
+              </A>.
+            </P>
+          </TD>
+        </TR>
+      </TABLE>
+    </DIV>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+  </BODY>
+</HTML>

Meade.net/ReferenceCountedObject.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace ASCOM.Meade.net
+{
+    [ComVisible(false)]
+    public class ReferenceCountedObjectBase
+    {
+        public ReferenceCountedObjectBase()
+        {
+            // We increment the global count of objects.
+            Server.CountObject();
+        }
+
+        ~ReferenceCountedObjectBase()
+        {
+            // We decrement the global count of objects.
+            Server.UncountObject();
+            // We then immediately test to see if we the conditions
+            // are right to attempt to terminate this server application.
+            Server.ExitIf();
+        }
+    }
+}

Meade.net/SetupDialogForm.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows.Forms;
+using ASCOM.Utilities;
+using ASCOM.Meade.net;
+
+namespace ASCOM.Meade.net
+{
+    [ComVisible(false)]					// Form not registered for COM!
+    public partial class SetupDialogForm : Form
+    {
+        public SetupDialogForm()
+        {
+            InitializeComponent();
+        }
+
+        private void cmdCancel_Click(object sender, EventArgs e) // Cancel button event handler
+        {
+            Close();
+        }
+
+        private void BrowseToAscom(object sender, EventArgs e) // Click on ASCOM logo event handler
+        {
+            try
+            {
+                System.Diagnostics.Process.Start("http://ascom-standards.org/");
+            }
+            catch (System.ComponentModel.Win32Exception noBrowser)
+            {
+                if (noBrowser.ErrorCode == -2147467259)
+                    MessageBox.Show(noBrowser.Message);
+            }
+            catch (System.Exception other)
+            {
+                MessageBox.Show(other.Message);
+            }
+        }      
+
+        public void SetProfile(ProfileProperties profileProperties)
+        {
+            chkTrace.Checked = profileProperties.TraceLogger;
+            // set the list of com ports to those that are currently available
+            comboBoxComPort.Items.Clear();
+            comboBoxComPort.Items.AddRange(System.IO.Ports.SerialPort.GetPortNames());      // use System.IO because it's static
+            // select the current port if possible
+            if (comboBoxComPort.Items.Contains(profileProperties.ComPort))
+            {
+                comboBoxComPort.SelectedItem = profileProperties.ComPort;
+            }
+        }
+
+        public ProfileProperties GetProfile()
+        {
+            var profileProperties = new ProfileProperties
+            {
+                TraceLogger = chkTrace.Checked,
+                ComPort = comboBoxComPort.SelectedItem.ToString()
+            };
+
+            return profileProperties;
+        }
+
+        private void SetupDialogForm_Shown(object sender, EventArgs e)
+        {
+            Activate();
+        }
+    }
+}

Meade.net/SetupDialogForm.designer.cs

@@ -0,0 +1,122 @@
+namespace ASCOM.Meade.net
+{
+    partial class SetupDialogForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SetupDialogForm));
+            this.cmdOK = new System.Windows.Forms.Button();
+            this.cmdCancel = new System.Windows.Forms.Button();
+            this.label1 = new System.Windows.Forms.Label();
+            this.picASCOM = new System.Windows.Forms.PictureBox();
+            this.label2 = new System.Windows.Forms.Label();
+            this.chkTrace = new System.Windows.Forms.CheckBox();
+            this.comboBoxComPort = new System.Windows.Forms.ComboBox();
+            ((System.ComponentModel.ISupportInitialize)(this.picASCOM)).BeginInit();
+            this.SuspendLayout();
+            // 
+            // cmdOK
+            // 
+            resources.ApplyResources(this.cmdOK, "cmdOK");
+            this.cmdOK.DialogResult = System.Windows.Forms.DialogResult.OK;
+            this.cmdOK.Name = "cmdOK";
+            this.cmdOK.UseVisualStyleBackColor = true;
+            // 
+            // cmdCancel
+            // 
+            resources.ApplyResources(this.cmdCancel, "cmdCancel");
+            this.cmdCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cmdCancel.Name = "cmdCancel";
+            this.cmdCancel.UseVisualStyleBackColor = true;
+            this.cmdCancel.Click += new System.EventHandler(this.cmdCancel_Click);
+            // 
+            // label1
+            // 
+            resources.ApplyResources(this.label1, "label1");
+            this.label1.Name = "label1";
+            // 
+            // picASCOM
+            // 
+            resources.ApplyResources(this.picASCOM, "picASCOM");
+            this.picASCOM.Cursor = System.Windows.Forms.Cursors.Hand;
+            this.picASCOM.Image = global::ASCOM.Meade.net.Properties.Resources.ASCOM;
+            this.picASCOM.Name = "picASCOM";
+            this.picASCOM.TabStop = false;
+            this.picASCOM.Click += new System.EventHandler(this.BrowseToAscom);
+            this.picASCOM.DoubleClick += new System.EventHandler(this.BrowseToAscom);
+            // 
+            // label2
+            // 
+            resources.ApplyResources(this.label2, "label2");
+            this.label2.Name = "label2";
+            // 
+            // chkTrace
+            // 
+            resources.ApplyResources(this.chkTrace, "chkTrace");
+            this.chkTrace.Name = "chkTrace";
+            this.chkTrace.UseVisualStyleBackColor = true;
+            // 
+            // comboBoxComPort
+            // 
+            this.comboBoxComPort.FormattingEnabled = true;
+            resources.ApplyResources(this.comboBoxComPort, "comboBoxComPort");
+            this.comboBoxComPort.Name = "comboBoxComPort";
+            // 
+            // SetupDialogForm
+            // 
+            resources.ApplyResources(this, "$this");
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.comboBoxComPort);
+            this.Controls.Add(this.chkTrace);
+            this.Controls.Add(this.label2);
+            this.Controls.Add(this.picASCOM);
+            this.Controls.Add(this.label1);
+            this.Controls.Add(this.cmdCancel);
+            this.Controls.Add(this.cmdOK);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.Name = "SetupDialogForm";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.Shown += new System.EventHandler(this.SetupDialogForm_Shown);
+            ((System.ComponentModel.ISupportInitialize)(this.picASCOM)).EndInit();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Button cmdOK;
+        private System.Windows.Forms.Button cmdCancel;
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.PictureBox picASCOM;
+        private System.Windows.Forms.Label label2;
+        private System.Windows.Forms.CheckBox chkTrace;
+        private System.Windows.Forms.ComboBox comboBoxComPort;
+    }
+}

Meade.net/SetupDialogForm.resx

@@ -0,0 +1,324 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="cmdOK.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Bottom, Right</value>
+  </data>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="cmdOK.Location" type="System.Drawing.Point, System.Drawing">
+    <value>281, 112</value>
+  </data>
+  <data name="cmdOK.Size" type="System.Drawing.Size, System.Drawing">
+    <value>59, 24</value>
+  </data>
+  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="cmdOK.TabIndex" type="System.Int32, mscorlib">
+    <value>0</value>
+  </data>
+  <data name="cmdOK.Text" xml:space="preserve">
+    <value>OK</value>
+  </data>
+  <data name="&gt;&gt;cmdOK.Name" xml:space="preserve">
+    <value>cmdOK</value>
+  </data>
+  <data name="&gt;&gt;cmdOK.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;cmdOK.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;cmdOK.ZOrder" xml:space="preserve">
+    <value>6</value>
+  </data>
+  <data name="cmdCancel.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Bottom, Right</value>
+  </data>
+  <data name="cmdCancel.Location" type="System.Drawing.Point, System.Drawing">
+    <value>281, 142</value>
+  </data>
+  <data name="cmdCancel.Size" type="System.Drawing.Size, System.Drawing">
+    <value>59, 25</value>
+  </data>
+  <data name="cmdCancel.TabIndex" type="System.Int32, mscorlib">
+    <value>1</value>
+  </data>
+  <data name="cmdCancel.Text" xml:space="preserve">
+    <value>Cancel</value>
+  </data>
+  <data name="&gt;&gt;cmdCancel.Name" xml:space="preserve">
+    <value>cmdCancel</value>
+  </data>
+  <data name="&gt;&gt;cmdCancel.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;cmdCancel.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;cmdCancel.ZOrder" xml:space="preserve">
+    <value>5</value>
+  </data>
+  <data name="label1.Location" type="System.Drawing.Point, System.Drawing">
+    <value>12, 9</value>
+  </data>
+  <data name="label1.Size" type="System.Drawing.Size, System.Drawing">
+    <value>123, 31</value>
+  </data>
+  <data name="label1.TabIndex" type="System.Int32, mscorlib">
+    <value>2</value>
+  </data>
+  <data name="label1.Text" xml:space="preserve">
+    <value>Meade AutoStar and AudioStar generic driver</value>
+  </data>
+  <data name="&gt;&gt;label1.Name" xml:space="preserve">
+    <value>label1</value>
+  </data>
+  <data name="&gt;&gt;label1.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;label1.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;label1.ZOrder" xml:space="preserve">
+    <value>4</value>
+  </data>
+  <data name="picASCOM.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
+    <value>Top, Right</value>
+  </data>
+  <data name="picASCOM.Location" type="System.Drawing.Point, System.Drawing">
+    <value>292, 9</value>
+  </data>
+  <data name="picASCOM.Size" type="System.Drawing.Size, System.Drawing">
+    <value>48, 56</value>
+  </data>
+  <data name="picASCOM.SizeMode" type="System.Windows.Forms.PictureBoxSizeMode, System.Windows.Forms">
+    <value>AutoSize</value>
+  </data>
+  <data name="picASCOM.TabIndex" type="System.Int32, mscorlib">
+    <value>3</value>
+  </data>
+  <data name="&gt;&gt;picASCOM.Name" xml:space="preserve">
+    <value>picASCOM</value>
+  </data>
+  <data name="&gt;&gt;picASCOM.Type" xml:space="preserve">
+    <value>System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;picASCOM.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;picASCOM.ZOrder" xml:space="preserve">
+    <value>3</value>
+  </data>
+  <data name="label2.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="label2.Location" type="System.Drawing.Point, System.Drawing">
+    <value>13, 90</value>
+  </data>
+  <data name="label2.Size" type="System.Drawing.Size, System.Drawing">
+    <value>58, 13</value>
+  </data>
+  <data name="label2.TabIndex" type="System.Int32, mscorlib">
+    <value>5</value>
+  </data>
+  <data name="label2.Text" xml:space="preserve">
+    <value>Comm Port</value>
+  </data>
+  <data name="&gt;&gt;label2.Name" xml:space="preserve">
+    <value>label2</value>
+  </data>
+  <data name="&gt;&gt;label2.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;label2.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;label2.ZOrder" xml:space="preserve">
+    <value>2</value>
+  </data>
+  <data name="chkTrace.AutoSize" type="System.Boolean, mscorlib">
+    <value>True</value>
+  </data>
+  <data name="chkTrace.Location" type="System.Drawing.Point, System.Drawing">
+    <value>77, 118</value>
+  </data>
+  <data name="chkTrace.Size" type="System.Drawing.Size, System.Drawing">
+    <value>69, 17</value>
+  </data>
+  <data name="chkTrace.TabIndex" type="System.Int32, mscorlib">
+    <value>6</value>
+  </data>
+  <data name="chkTrace.Text" xml:space="preserve">
+    <value>Trace on</value>
+  </data>
+  <data name="&gt;&gt;chkTrace.Name" xml:space="preserve">
+    <value>chkTrace</value>
+  </data>
+  <data name="&gt;&gt;chkTrace.Type" xml:space="preserve">
+    <value>System.Windows.Forms.CheckBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;chkTrace.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;chkTrace.ZOrder" xml:space="preserve">
+    <value>1</value>
+  </data>
+  <data name="comboBoxComPort.Location" type="System.Drawing.Point, System.Drawing">
+    <value>77, 87</value>
+  </data>
+  <data name="comboBoxComPort.Size" type="System.Drawing.Size, System.Drawing">
+    <value>90, 21</value>
+  </data>
+  <data name="comboBoxComPort.TabIndex" type="System.Int32, mscorlib">
+    <value>7</value>
+  </data>
+  <data name="&gt;&gt;comboBoxComPort.Name" xml:space="preserve">
+    <value>comboBoxComPort</value>
+  </data>
+  <data name="&gt;&gt;comboBoxComPort.Type" xml:space="preserve">
+    <value>System.Windows.Forms.ComboBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="&gt;&gt;comboBoxComPort.Parent" xml:space="preserve">
+    <value>$this</value>
+  </data>
+  <data name="&gt;&gt;comboBoxComPort.ZOrder" xml:space="preserve">
+    <value>0</value>
+  </data>
+  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+    <value>True</value>
+  </metadata>
+  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
+    <value>6, 13</value>
+  </data>
+  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
+    <value>350, 175</value>
+  </data>
+  <data name="$this.StartPosition" type="System.Windows.Forms.FormStartPosition, System.Windows.Forms">
+    <value>CenterScreen</value>
+  </data>
+  <data name="$this.Text" xml:space="preserve">
+    <value>Meade.net Setup</value>
+  </data>
+  <data name="&gt;&gt;$this.Name" xml:space="preserve">
+    <value>SetupDialogForm</value>
+  </data>
+  <data name="&gt;&gt;$this.Type" xml:space="preserve">
+    <value>System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+</root>

Meade.net/SharedResources.cs

@@ -0,0 +1,380 @@
+//
+// ================
+// Shared Resources
+// ================
+//
+// This class is a container for all shared resources that may be needed
+// by the drivers served by the Local Server. 
+//
+// NOTES:
+//
+//	* ALL DECLARATIONS MUST BE STATIC HERE!! INSTANCES OF THIS CLASS MUST NEVER BE CREATED!
+//
+// Written by:	Bob Denny	29-May-2007
+// Modified by Chris Rowland and Peter Simpson to hamdle multiple hardware devices March 2011
+//
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ASCOM;
+using ASCOM.Utilities;
+
+namespace ASCOM.Meade.net
+{
+    public class ProfileProperties
+    {
+        // properies that are part of the profile
+        public string ComPort { get; set; }
+        public bool TraceLogger { get; set; }
+    }
+
+    /// <summary>
+    /// The resources shared by all drivers and devices, in this example it's a serial port with a shared SendMessage method
+    /// an idea for locking the message and handling connecting is given.
+    /// In reality extensive changes will probably be needed.
+    /// Multiple drivers means that several applications connect to the same hardware device, aka a hub.
+    /// Multiple devices means that there are more than one instance of the hardware, such as two focusers.
+    /// In this case there needs to be multiple instances of the hardware connector, each with it's own connection count.
+    /// </summary>
+    public static class SharedResources
+    {
+        // object used for locking to prevent multiple drivers accessing common code at the same time
+        private static readonly object lockObject = new object();
+
+        // Shared serial port. This will allow multiple drivers to use one single serial port.
+        private static ASCOM.Utilities.Serial s_sharedSerial; // Shared serial port
+
+        //
+        // Public access to shared resources
+        //
+
+        #region single serial port connector
+
+        //
+        // this region shows a way that a single serial port could be connected to by multiple 
+        // drivers.
+        //
+        // Connected is used to handle the connections to the port.
+        //
+        // SendMessage is a way that messages could be sent to the hardware without
+        // conflicts between different drivers.
+        //
+        // All this is for a single connection, multiple connections would need multiple ports
+        // and a way to handle connecting and disconnection from them - see the
+        // multi driver handling section for ideas.
+        //
+
+        /// <summary>
+        /// Shared serial port
+        /// </summary>
+        public static ASCOM.Utilities.Serial SharedSerial => s_sharedSerial ?? (s_sharedSerial = new ASCOM.Utilities.Serial());
+
+        /// <summary>
+        /// number of connections to the shared serial port
+        /// </summary>
+        public static int Connections { get; set; } = 0;
+
+        public static void SendBlind(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+            }
+        }
+
+        public static bool SendBool(string message)
+        {
+            SharedSerial.ClearBuffers();
+            return SendChar(message) == "1";
+        }
+
+        /// <summary>
+        /// Example of a shared SendMessage method, the lock
+        /// prevents different drivers tripping over one another.
+        /// It needs error handling and assumes that the message will be sent unchanged
+        /// and that the reply will always be terminated by a "#" character.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public static string SendString(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+                return SharedSerial.ReceiveTerminated("#").TrimEnd('#');
+            }
+        }
+
+        public static string SendChar(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+                return SharedSerial.ReceiveCounted(1);
+            }
+        }
+
+        public static string ReadTerminated()
+        {
+            lock (lockObject)
+            {
+                return SharedSerial.ReceiveTerminated("#");
+            }
+        }
+
+        /// <summary>
+        /// Example of handling connecting to and disconnection from the
+        /// shared serial port.
+        /// Needs error handling
+        /// the port name etc. needs to be set up first, this could be done by the driver
+        /// checking Connected and if it's false setting up the port before setting connected to true.
+        /// It could also be put here.
+        /// </summary>
+        public static bool Connected
+        {
+            set
+            {
+                lock (lockObject)
+                {
+                    if (value)
+                    {
+                        if (Connections == 0)
+                            SharedSerial.Connected = true;
+                        Connections++;
+                    }
+                    else
+                    {
+                        Connections--;
+                        if (Connections <= 0)
+                        {
+                            SharedSerial.Connected = false;
+                        }
+                    }
+                }
+            }
+            get { return SharedSerial.Connected; }
+        }
+
+        #endregion
+
+        #region Profile
+
+        internal static string driverID = "ASCOM.MeadeGeneric.Telescope";
+
+        // Constants used for Profile persistence
+        internal static string comPortProfileName = "COM Port";
+        internal static string traceStateProfileName = "Trace Level";
+
+        public static void WriteProfile(ProfileProperties profileProperties)
+        {
+            lock (lockObject)
+            {
+                using (Profile driverProfile = new Profile())
+                {
+                    driverProfile.DeviceType = "Telescope";
+                    driverProfile.WriteValue(driverID, traceStateProfileName, profileProperties.TraceLogger.ToString());
+                    driverProfile.WriteValue(driverID, comPortProfileName, profileProperties.ComPort);
+                }
+            }
+        }
+
+        private static readonly string comPortDefault = "COM1";
+        internal static string traceStateDefault = "false";
+
+        public static ProfileProperties ReadProfile()
+        {
+            lock (lockObject)
+            {
+                ProfileProperties profileProperties = new ProfileProperties();
+                using (Profile driverProfile = new Profile())
+                {
+                    driverProfile.DeviceType = "Telescope";
+                    profileProperties.ComPort =
+                        driverProfile.GetValue(driverID, comPortProfileName, string.Empty, comPortDefault);
+                    profileProperties.TraceLogger = Convert.ToBoolean(driverProfile.GetValue(driverID,
+                        traceStateProfileName, string.Empty, traceStateDefault));
+                }
+
+                return profileProperties;
+            }
+        }
+
+        #endregion
+
+        #region SetupDialog
+
+        public static void SetupDialog()
+        {
+            // consider only showing the setup dialog if not connected
+            // or call a different dialog if connected
+            if (Connections > 0)
+            {
+                System.Windows.Forms.MessageBox.Show("Already connected, please disconnect before altering settings");
+                return;
+            }
+
+            var profileProperties = ReadProfile();
+
+            using (SetupDialogForm F = new SetupDialogForm())
+            {
+                F.SetProfile(profileProperties);
+                
+                var result = F.ShowDialog();
+                if (result == System.Windows.Forms.DialogResult.OK)
+                {
+                    profileProperties = F.GetProfile();
+
+                    WriteProfile(profileProperties); // Persist device configuration values to the ASCOM Profile store
+                }
+            }
+        }
+
+        #endregion
+
+        #region Multi Driver handling
+
+        // this section illustrates how multiple drivers could be handled,
+        // it's for drivers where multiple connections to the hardware can be made and ensures that the
+        // hardware is only disconnected from when all the connected devices have disconnected.
+
+        // It is NOT a complete solution!  This is to give ideas of what can - or should be done.
+        //
+        // An alternative would be to move the hardware control here, handle connecting and disconnecting,
+        // and provide the device with a suitable connection to the hardware.
+        //
+        /// <summary>
+        /// dictionary carrying device connections.
+        /// The Key is the connection number that identifies the device, it could be the COM port name,
+        /// USB ID or IP Address, the Value is the DeviceHardware class
+        /// </summary>
+        private static Dictionary<string, DeviceHardware> connectedDevices = new Dictionary<string, DeviceHardware>();
+
+        /// <summary>
+        /// This is called in the driver Connect(true) property,
+        /// it add the device id to the list of devices if it's not there and increments the device count.
+        /// </summary>
+        /// <param name="deviceId"></param>
+        public static void Connect(string deviceId)
+        {
+            lock (lockObject)
+            {
+                if (!connectedDevices.ContainsKey(deviceId))
+                    connectedDevices.Add(deviceId, new DeviceHardware());
+                connectedDevices[deviceId].count++; // increment the value
+
+                if (deviceId == "Serial")
+                {
+                    if (connectedDevices[deviceId].count == 1)
+                    {
+                        var profileProperties = ReadProfile();
+                        SharedResources.SharedSerial.PortName = profileProperties.ComPort;
+                        SharedResources.SharedSerial.DTREnable = false;
+                        SharedResources.SharedSerial.RTSEnable = false;
+                        SharedResources.SharedSerial.DataBits = 8;
+                        SharedResources.SharedSerial.StopBits = SerialStopBits.One;
+                        SharedResources.SharedSerial.Parity = SerialParity.None;
+                        SharedResources.SharedSerial.Speed = SerialSpeed.ps9600;
+                        SharedResources.SharedSerial.Handshake = SerialHandshake.None;
+                        SharedResources.SharedSerial.Connected = true;
+
+                        string firmware = SendString(":GVN#");
+                    }
+                }
+            }
+        }
+
+        public static void Disconnect(string deviceId)
+        {
+            lock (lockObject)
+            {
+                if (connectedDevices.ContainsKey(deviceId))
+                {
+                    connectedDevices[deviceId].count--;
+                    if (connectedDevices[deviceId].count <= 0)
+                    {
+                        connectedDevices.Remove(deviceId);
+                        if (deviceId == "Serial")
+                        {
+                            SharedResources.SharedSerial.Connected = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static bool IsConnected(string deviceId)
+        {
+            if (connectedDevices.ContainsKey(deviceId))
+                return (connectedDevices[deviceId].count > 0);
+            else
+                return false;
+        }
+
+        #endregion
+
+        public static void Lock(Action action)
+        {
+            lock (lockObject)
+            {
+                action();
+            }
+        }
+
+        public static T Lock<T>(Func<T> func)
+        {
+            lock (lockObject)
+            {
+                return func();
+            }
+        }
+
+        /// <summary>
+        /// Skeleton of a hardware class, all this does is hold a count of the connections,
+        /// in reality extra code will be needed to handle the hardware in some way
+        /// </summary>
+        public class DeviceHardware
+        {
+            private int _count;
+
+            internal int count
+            {
+                set => _count = value;
+                get => _count;
+            }
+
+            internal DeviceHardware()
+            {
+                count = 0;
+            }
+        }
+
+        //#region ServedClassName attribute
+        ///// <summary>
+        ///// This is only needed if the driver is targeted at  platform 5.5, it is included with Platform 6
+        ///// </summary>
+        //[global::System.AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+        //public sealed class ServedClassNameAttribute : Attribute
+        //{
+        //    // See the attribute guidelines at 
+        //    //  http://go.microsoft.com/fwlink/?LinkId=85236
+
+        //    /// <summary>
+        //    /// Gets or sets the 'friendly name' of the served class, as registered with the ASCOM Chooser.
+        //    /// </summary>
+        //    /// <value>The 'friendly name' of the served class.</value>
+        //    public string DisplayName { get; private set; }
+        //    /// <summary>
+        //    /// Initializes a new instance of the <see cref="ServedClassNameAttribute"/> class.
+        //    /// </summary>
+        //    /// <param name="servedClassName">The 'friendly name' of the served class.</param>
+        //    public ServedClassNameAttribute(string servedClassName)
+        //    {
+        //        DisplayName = servedClassName;
+        //    }
+        //}
+        //#endregion
+    }
+}

Meade.net/app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.1"/></startup></configuration>

Meade.net/frmMain.Designer.cs

@@ -0,0 +1,63 @@
+using System;
+
+namespace ASCOM.Meade.net
+{
+    partial class frmMain
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.label1 = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.Location = new System.Drawing.Point(12, 10);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(199, 33);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "This is an ASCOM driver, not a program for you to use.";
+            // 
+            // frmMain
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(233, 52);
+            this.Controls.Add(this.label1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
+            this.Name = "frmMain";
+            this.Text = "Meade.net Driver Server";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+
+    }
+}
+

Meade.net/frmMain.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+namespace ASCOM.Meade.net
+{
+    public partial class frmMain : Form
+    {
+        delegate void SetTextCallback(string text);
+
+        public frmMain()
+        {
+            InitializeComponent();
+        }
+
+    }
+}

Meade.net/frmMain.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>