using Microsoft.VisualBasic;
using Microsoft.VisualBasic.ApplicationServices;
using Microsoft.VisualBasic.CompilerServices;
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Windows.Forms;


namespace HPG_68D.My
{
  [GeneratedCode("MyTemplate", "8.0.0.0")]
  [HideModuleName]
  [StandardModule]
  internal sealed class MyProject
  {
    private static readonly ThreadSafeObjectProvider<MyComputer> m_ComputerObjectProvider = new ThreadSafeObjectProvider<MyComputer>();
    private static readonly ThreadSafeObjectProvider<MyApplication> m_AppObjectProvider = new ThreadSafeObjectProvider<MyApplication>();
    private static readonly ThreadSafeObjectProvider<User> m_UserObjectProvider = new ThreadSafeObjectProvider<User>();
    private static ThreadSafeObjectProvider<MyForms> m_MyFormsObjectProvider = new ThreadSafeObjectProvider<MyForms>();
    private static readonly ThreadSafeObjectProvider<MyWebServices> m_MyWebServicesObjectProvider = new ThreadSafeObjectProvider<MyWebServices>();

    [DebuggerNonUserCode]
    static MyProject()
    {
    }

    [HelpKeyword("My.Computer")]
    internal static MyComputer Computer
    {
      [DebuggerHidden] get => m_ComputerObjectProvider.GetInstance;
    }

    [HelpKeyword("My.Application")]
    internal static MyApplication Application
    {
      [DebuggerHidden] get => m_AppObjectProvider.GetInstance;
    }

    [HelpKeyword("My.User")]
    internal static User User
    {
      [DebuggerHidden] get => m_UserObjectProvider.GetInstance;
    }

    [HelpKeyword("My.Forms")]
    internal static MyForms Forms
    {
      [DebuggerHidden] get => m_MyFormsObjectProvider.GetInstance;
    }

    [HelpKeyword("My.WebServices")]
    internal static MyWebServices WebServices
    {
      [DebuggerHidden] get => m_MyWebServicesObjectProvider.GetInstance;
    }

    [MyGroupCollection("System.Windows.Forms.Form", "Create__Instance__", "Dispose__Instance__", "My.MyProject.Forms")]
    [EditorBrowsable(EditorBrowsableState.Never)]
    internal sealed class MyForms
    {
      public _2ToneForm m__2ToneForm;
      public _5ToneForm m__5ToneForm;
      public AboutForm m_AboutForm;
      public BeepForm m_BeepForm;
      public ChannelEditForm m_ChannelEditForm;
      public ChannelMsg m_ChannelMsg;
      public ComForm m_ComForm;
      public DtmfForm m_DtmfForm;
      public InputPasswordForm m_InputPasswordForm;
      public MDIParent1 m_MDIParent1;
      public MSCommReadForm m_MSCommReadForm;
      public MSCommWriteForm m_MSCommWriteForm;
      public MsgForm m_MsgForm;
      public PasswordForm m_PasswordForm;
      public RadioMsgForm m_RadioMsgForm;
      public ScanFuncMsgForm m_ScanFuncMsgForm;
      public SofeMsgForm m_SofeMsgForm;
      public SOSMsgForm m_SOSMsgForm;
      public TypeFuncMsgForm m_TypeFuncMsgForm;
      public TypeMsgForm m_TypeMsgForm;
      [ThreadStatic]
      private static Hashtable m_FormBeingCreated;

      public _2ToneForm _2ToneForm
      {
        [DebuggerNonUserCode] get
        {
          m__2ToneForm = Create__Instance__<_2ToneForm>(m__2ToneForm);
          return m__2ToneForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m__2ToneForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<_2ToneForm>(ref m__2ToneForm);
        }
      }

      public _5ToneForm _5ToneForm
      {
        [DebuggerNonUserCode] get
        {
          m__5ToneForm = Create__Instance__<_5ToneForm>(m__5ToneForm);
          return m__5ToneForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m__5ToneForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<_5ToneForm>(ref m__5ToneForm);
        }
      }

      public AboutForm AboutForm
      {
        [DebuggerNonUserCode] get
        {
          m_AboutForm = Create__Instance__<AboutForm>(m_AboutForm);
          return m_AboutForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_AboutForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<AboutForm>(ref m_AboutForm);
        }
      }

      public BeepForm BeepForm
      {
        [DebuggerNonUserCode] get
        {
          m_BeepForm = Create__Instance__<BeepForm>(m_BeepForm);
          return m_BeepForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_BeepForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<BeepForm>(ref m_BeepForm);
        }
      }

      public ChannelEditForm ChannelEditForm
      {
        [DebuggerNonUserCode] get
        {
          m_ChannelEditForm = Create__Instance__<ChannelEditForm>(m_ChannelEditForm);
          return m_ChannelEditForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_ChannelEditForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<ChannelEditForm>(ref m_ChannelEditForm);
        }
      }

      public ChannelMsg ChannelMsg
      {
        [DebuggerNonUserCode] get
        {
          m_ChannelMsg = Create__Instance__<ChannelMsg>(m_ChannelMsg);
          return m_ChannelMsg;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_ChannelMsg)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<ChannelMsg>(ref m_ChannelMsg);
        }
      }

      public ComForm ComForm
      {
        [DebuggerNonUserCode] get
        {
          m_ComForm = Create__Instance__<ComForm>(m_ComForm);
          return m_ComForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_ComForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<ComForm>(ref m_ComForm);
        }
      }

      public DtmfForm DtmfForm
      {
        [DebuggerNonUserCode] get
        {
          m_DtmfForm = Create__Instance__<DtmfForm>(m_DtmfForm);
          return m_DtmfForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_DtmfForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<DtmfForm>(ref m_DtmfForm);
        }
      }

      public InputPasswordForm InputPasswordForm
      {
        [DebuggerNonUserCode] get
        {
          m_InputPasswordForm = Create__Instance__<InputPasswordForm>(m_InputPasswordForm);
          return m_InputPasswordForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_InputPasswordForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<InputPasswordForm>(ref m_InputPasswordForm);
        }
      }

      public MDIParent1 MDIParent1
      {
        [DebuggerNonUserCode] get
        {
          m_MDIParent1 = Create__Instance__<MDIParent1>(m_MDIParent1);
          return m_MDIParent1;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_MDIParent1)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<MDIParent1>(ref m_MDIParent1);
        }
      }

      public MSCommReadForm MSCommReadForm
      {
        [DebuggerNonUserCode] get
        {
          m_MSCommReadForm = Create__Instance__<MSCommReadForm>(m_MSCommReadForm);
          return m_MSCommReadForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_MSCommReadForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<MSCommReadForm>(ref m_MSCommReadForm);
        }
      }

      public MSCommWriteForm MSCommWriteForm
      {
        [DebuggerNonUserCode] get
        {
          m_MSCommWriteForm = Create__Instance__<MSCommWriteForm>(m_MSCommWriteForm);
          return m_MSCommWriteForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_MSCommWriteForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<MSCommWriteForm>(ref m_MSCommWriteForm);
        }
      }

      public MsgForm MsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_MsgForm = Create__Instance__<MsgForm>(m_MsgForm);
          return m_MsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_MsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<MsgForm>(ref m_MsgForm);
        }
      }

      public PasswordForm PasswordForm
      {
        [DebuggerNonUserCode] get
        {
          m_PasswordForm = Create__Instance__<PasswordForm>(m_PasswordForm);
          return m_PasswordForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_PasswordForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<PasswordForm>(ref m_PasswordForm);
        }
      }

      public RadioMsgForm RadioMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_RadioMsgForm = Create__Instance__<RadioMsgForm>(m_RadioMsgForm);
          return m_RadioMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_RadioMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<RadioMsgForm>(ref m_RadioMsgForm);
        }
      }

      public ScanFuncMsgForm ScanFuncMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_ScanFuncMsgForm = Create__Instance__<ScanFuncMsgForm>(m_ScanFuncMsgForm);
          return m_ScanFuncMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_ScanFuncMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<ScanFuncMsgForm>(ref m_ScanFuncMsgForm);
        }
      }

      public SofeMsgForm SofeMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_SofeMsgForm = Create__Instance__<SofeMsgForm>(m_SofeMsgForm);
          return m_SofeMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_SofeMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<SofeMsgForm>(ref m_SofeMsgForm);
        }
      }

      public SOSMsgForm SOSMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_SOSMsgForm = Create__Instance__<SOSMsgForm>(m_SOSMsgForm);
          return m_SOSMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_SOSMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<SOSMsgForm>(ref m_SOSMsgForm);
        }
      }

      public TypeFuncMsgForm TypeFuncMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_TypeFuncMsgForm = Create__Instance__<TypeFuncMsgForm>(m_TypeFuncMsgForm);
          return m_TypeFuncMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_TypeFuncMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<TypeFuncMsgForm>(ref m_TypeFuncMsgForm);
        }
      }

      public TypeMsgForm TypeMsgForm
      {
        [DebuggerNonUserCode] get
        {
          m_TypeMsgForm = Create__Instance__<TypeMsgForm>(m_TypeMsgForm);
          return m_TypeMsgForm;
        }
        [DebuggerNonUserCode] set
        {
          if (value == m_TypeMsgForm)
            return;
          if (value != null)
            throw new ArgumentException("Property can only be set to Nothing");
          Dispose__Instance__<TypeMsgForm>(ref m_TypeMsgForm);
        }
      }

      [DebuggerHidden]
      private static T Create__Instance__<T>(T Instance) where T : Form, new()
      {
        if (Instance != null && !Instance.IsDisposed)
          return Instance;
        if (m_FormBeingCreated != null)
        {
          if (m_FormBeingCreated.ContainsKey(typeof (T)))
            throw new InvalidOperationException(Utils.GetResourceString("WinForms_RecursiveFormCreate"));
        }
        else
          m_FormBeingCreated = new Hashtable();
        m_FormBeingCreated.Add(typeof (T), null);
        try
        {
          return new T();
        }
        catch (TargetInvocationException ex)
        {
          // ISSUE: unable to correctly present filter
          ProjectData.SetProjectError(ex);
          if (ex.InnerException != null)
          {
            //SuccessfulFiltering;
          }
          else
            throw new InvalidOperationException(Utils.GetResourceString("WinForms_SeeInnerException", ex.InnerException.Message), ex.InnerException);
        }
        finally
        {
          m_FormBeingCreated.Remove(typeof (T));
        }
        throw new InvalidOperationException("Upssssss!!!!");
      }

      [DebuggerHidden]
      private void Dispose__Instance__<T>(ref T instance) where T : Form
      {
        instance.Dispose();
        instance = default (T);
      }

      [EditorBrowsable(EditorBrowsableState.Never)]
      [DebuggerHidden]
      public MyForms()
      {
      }

      [EditorBrowsable(EditorBrowsableState.Never)]
      public override bool Equals(object o) => base.Equals(RuntimeHelpers.GetObjectValue(o));

      [EditorBrowsable(EditorBrowsableState.Never)]
      public override int GetHashCode() => base.GetHashCode();

      [EditorBrowsable(EditorBrowsableState.Never)]
      internal new Type GetType() => typeof (MyForms);

      [EditorBrowsable(EditorBrowsableState.Never)]
      public override string ToString() => base.ToString();
    }

    [MyGroupCollection("System.Web.Services.Protocols.SoapHttpClientProtocol", "Create__Instance__", "Dispose__Instance__", "")]
    [EditorBrowsable(EditorBrowsableState.Never)]
    internal sealed class MyWebServices
    {
      [EditorBrowsable(EditorBrowsableState.Never)]
      [DebuggerHidden]
      public override bool Equals(object o) => base.Equals(RuntimeHelpers.GetObjectValue(o));

      [DebuggerHidden]
      [EditorBrowsable(EditorBrowsableState.Never)]
      public override int GetHashCode() => base.GetHashCode();

      [DebuggerHidden]
      [EditorBrowsable(EditorBrowsableState.Never)]
      internal new Type GetType() => typeof (MyWebServices);

      [DebuggerHidden]
      [EditorBrowsable(EditorBrowsableState.Never)]
      public override string ToString() => base.ToString();

      [DebuggerHidden]
      private static T Create__Instance__<T>(T instance) where T : new()
      {
        return instance == null ? new T() : instance;
      }

      [DebuggerHidden]
      private void Dispose__Instance__<T>(ref T instance) => instance = default (T);

      [EditorBrowsable(EditorBrowsableState.Never)]
      [DebuggerHidden]
      public MyWebServices()
      {
      }
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    [ComVisible(false)]
    internal sealed class ThreadSafeObjectProvider<T> where T : new()
    {
      [ThreadStatic, CompilerGenerated]
      private static T m_ThreadStaticValue;
      internal T GetInstance
      {
        [DebuggerHidden] get
        {
          if (ThreadSafeObjectProvider<T>.m_ThreadStaticValue == null)
            ThreadSafeObjectProvider<T>.m_ThreadStaticValue = new T();
          
          return ThreadSafeObjectProvider<T>.m_ThreadStaticValue;
        }
      }

      [DebuggerHidden]
      [EditorBrowsable(EditorBrowsableState.Never)]
      public ThreadSafeObjectProvider()
      {
      }
    }
  }
}
