[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)

[mono-project.git] / mcs / class / System.Windows.Forms / System.Windows.Forms / AxHost.cs

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
//
// Authors:
//      Peter Bartok    <pbartok@novell.com>
//
//

using System;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;

namespace System.Windows.Forms {
        [MonoTODO("Possibly implement this for Win32; find a way for Linux and Mac")]
        [DefaultEvent("Enter")]
        [Designer("System.Windows.Forms.Design.AxHostDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
        [DesignTimeVisible(false)]
        [ToolboxItem(false)]
        [ClassInterface (ClassInterfaceType.AutoDispatch)]
        [ComVisible (true)]
        public abstract class AxHost : Control, ISupportInitialize, ICustomTypeDescriptor {
                #region AxHost Subclasses
                #region AxHost.ActiveXInvokeKind Enum
                public enum ActiveXInvokeKind {
                        MethodInvoke    = 0,
                        PropertyGet     = 1,
                        PropertySet     = 2
                }
                #endregion      // AxHost.ActiveXInvokeKind Enum

                #region AxHost.AxComponentEditor Class
                [ComVisible (false)]
                public class AxComponentEditor : System.Windows.Forms.Design.WindowsFormsComponentEditor {
                        public AxComponentEditor ()
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public override bool EditComponent (ITypeDescriptorContext context, object obj, IWin32Window parent)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }
                #endregion      // AxHost.AxComponentEditor Class

                #region AxHost.ClsidAttribute
                [AttributeUsage(AttributeTargets.Class,Inherited=false)]
                public sealed class ClsidAttribute : Attribute {
                        string clsid;

                        public ClsidAttribute (string clsid)
                        {
                                this.clsid = clsid;
                        }

                        public string Value {
                                get { return clsid; }
                        }
                }
                #endregion AxHost.ClsidAttribute
                
                #region AxHost.ConnectionPointCookie
                public class ConnectionPointCookie {
                        public ConnectionPointCookie (object source, object sink, Type eventInterface)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public void Disconnect ()
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        ~ConnectionPointCookie ()
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }
                #endregion      // AxHost.ConnectionPointCookie
                
                #region AxHost.InvalidActiveXStateException  Class
                public class InvalidActiveXStateException : Exception {
                        private string mName;
                        private ActiveXInvokeKind mKind;

                        public InvalidActiveXStateException ()
                        {

                        }

                        public InvalidActiveXStateException (string name, ActiveXInvokeKind kind)
                        {
                                mName = name;
                                mKind = kind;
                        }

                        public override string ToString ()
                        {
                                if(mKind == ActiveXInvokeKind.MethodInvoke)
                                        return "Invoke:" + mName;
                                else if(mKind == ActiveXInvokeKind.PropertyGet)
                                        return "PropertyGet:" + mName;
                                else if(mKind == ActiveXInvokeKind.PropertySet)
                                        return "PropertySet:" + mName;

                                return base.ToString();
                        }
                }
                #endregion      // AxHost.InvalidActiveXStateException  Class
                        
                #region AxHost.State Class
                [Serializable]
                [TypeConverter("System.ComponentModel.TypeConverter, " + Consts.AssemblySystem)]
                public class State : ISerializable {
                        public State (Stream ms, int storageType, bool manualUpdate, string licKey)
                        {
                                //throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        protected State (SerializationInfo info, StreamingContext context)
                        {
                        }

                        void ISerializable.GetObjectData (SerializationInfo si,StreamingContext context)
                        {
                                //throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }
                #endregion      // AxHost.State Class

                #region AxHost.TypeLibraryTimeStampAttribute Class
                [AttributeUsage(AttributeTargets.Assembly, Inherited=false)]
                public sealed class TypeLibraryTimeStampAttribute : Attribute {
                        public TypeLibraryTimeStampAttribute (string timestamp)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public DateTime Value {
                                get {
                                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                                }
                        }
                }
                #endregion      // AxHost.TypeLibraryTimeStampAttribute Class

                #region AxHost.StateConverter Class
                public class StateConverter : System.ComponentModel.TypeConverter {
                        public StateConverter ()
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public override object ConvertFrom (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        public override object ConvertTo (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
                        {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }
                #endregion      // AxHost.StateConverter Class
                #endregion      // AxHost Subclasses

                //private int flags;
                private Guid clsid;
                private object instance;
                private AboutBoxDelegate aboutDelegate = null;
                private AxHost.State ocxState = null;
                static bool runningOnWindows;

                #region Protected Constructors

                protected AxHost (string clsid) : this(clsid, 0)
                {

                }

                protected AxHost (string clsid, int flags)
                {
                        this.clsid = new Guid(clsid);
                        //this.flags = flags;
                        this.instance = null;

                        PlatformID pid = Environment.OSVersion.Platform;
                        runningOnWindows = ((int) pid != 128 && (int) pid != 4 && (int) pid != 6);
                }
                #endregion      // Public Instance Properties

                #region Public Instance Properties
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override Color BackColor {
                        get {
                                return base.BackColor;
                        }
                        set {
                                base.BackColor = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                public override Image BackgroundImage {
                        get {
                                return base.BackgroundImage;
                        }

                        set {
                                base.BackgroundImage = value;
                        }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                public override ImageLayout BackgroundImageLayout {
                        get {
                                return base.BackgroundImageLayout;
                        }

                        set {
                                base.BackgroundImageLayout = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                public ContainerControl ContainingControl {
                        get {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }

                        set {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override ContextMenu ContextMenu {
                        get {
                                return base.ContextMenu;
                        }

                        set {
                                base.ContextMenu = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override Cursor Cursor {
                        get {
                                return base.Cursor;
                        }

                        set {
                                base.Cursor = value;
                        }
                }
                
                [Browsable (false)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                public bool EditMode {
                        get {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new virtual bool Enabled {
                        get {
                                return base.Enabled;
                        }

                        set {
                                base.Enabled = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override Font Font {
                        get {
                                return base.Font;
                        }

                        set {
                                base.Font = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override Color ForeColor {
                        get { 
                                return base.ForeColor;
                        }

                        set {
                                base.ForeColor = value;
                        }
                }
                
                [Browsable (false)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                public bool HasAboutBox {
                        get {
                                return aboutDelegate != null;
                        }
                }

                [Browsable (false)]
                [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new ImeMode ImeMode {
                        get { 
                                return base.ImeMode;
                        }
                        set { 
                                base.ImeMode = value;
                        }
                }
                
                [Browsable (false)]
                [DefaultValue (null)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                [RefreshProperties (RefreshProperties.All)]
                public AxHost.State OcxState {
                        get {
                                return ocxState;
                        }

                        set {
                                if (ocxState == value || value == null)
                                {
                                        return;
                                }
                                this.ocxState = value;
                        }
                }
                
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                [Localizable (true)]
                public new virtual bool RightToLeft {
                        get {
                                return base.RightToLeft == System.Windows.Forms.RightToLeft.Yes;
                        }

                        set {
                                base.RightToLeft = (value ? System.Windows.Forms.RightToLeft.Yes : 
                                                       System.Windows.Forms.RightToLeft.No);
                        }
                }
                
                public override ISite Site {
                        set {
                                throw new NotImplementedException("COM/ActiveX support is not implemented");
                        }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public override string Text {
                        get { return base.Text; }
                        set { base.Text = value; }
                }
                #endregion      // Protected Constructors
                
                #region Protected Instance Properties
                protected override CreateParams CreateParams {
                        get { return base.CreateParams; }
                }
                
                protected override Size DefaultSize {
                        get {
                                return new Size (75, 23);
                        }
                }
                #endregion      // Protected Instance Properties

                #region Protected Static Methods
                [CLSCompliant(false)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static Color GetColorFromOleColor (uint color)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static Font GetFontFromIFont (object font)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static Font GetFontFromIFontDisp (object font)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static object GetIFontDispFromFont (Font font)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static object GetIFontFromFont (Font font)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static object GetIPictureDispFromPicture (Image image)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static object GetIPictureFromCursor (Cursor cursor)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static object GetIPictureFromPicture (Image image)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static double GetOADateFromTime (DateTime time)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [CLSCompliant(false)]
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static uint GetOleColorFromColor (Color color)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static Image GetPictureFromIPicture (object picture)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static Image GetPictureFromIPictureDisp (object picture)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected static DateTime GetTimeFromOADate (double date)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }
                #endregion      // Protected Static Methods

                #region Public Instance Methods
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                [MonoTODO]
                public void BeginInit ()
                {
                }
                
                public void DoVerb (int verb)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                [MonoTODO]
                public void EndInit ()
                {
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                public object GetOcx ()
                {
                        return instance;
                }
                
                public bool HasPropertyPages ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                public void InvokeEditMode ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                public void MakeDirty ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                public override bool PreProcessMessage (ref Message msg)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                public void ShowAboutBox ()
                {
                        if (aboutDelegate != null)
                                this.aboutDelegate();
                }
                
                public void ShowPropertyPages ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                public void ShowPropertyPages (Control control)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                #endregion      // Public Instance Methods

                #region Protected Instance Methods
                protected virtual void AttachInterfaces ()
                {

                }
                
                protected override void CreateHandle ()
                {
                        if(IsRunningOnWindows && !base.IsHandleCreated) {
                                GetActiveXInstance ();
                                AttachInterfaces ();

                                base.CreateHandle ();
                        } else {
                                throw new NotSupportedException ();
                        }
                }

                private void GetActiveXInstance()
                {
                        if (this.instance == null) {
                                object obj;
                                CoCreateInstance (ref clsid, null, 1, ref IID_IUnknown, out obj);
                                this.instance = obj;
                        }
                }

                protected virtual object CreateInstanceCore (Guid clsid)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }


                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected virtual void CreateSink ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                protected override void DestroyHandle ()
                {
                        base.DestroyHandle();
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected virtual void DetachSink ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                protected override void Dispose (bool disposing)
                {
                        if(disposing) {
                                if(this.instance != null)
                                        Marshal.ReleaseComObject (this.instance);
                                this.instance = null;
                        }
                        base.Dispose(disposing);
                }

                [EditorBrowsable (EditorBrowsableState.Never)]
                public new void DrawToBitmap (Bitmap bitmap, Rectangle targetBounds)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected new virtual Rectangle GetScaledBounds (Rectangle bounds, SizeF factor, BoundsSpecified specified)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                protected override bool IsInputChar (char charCode)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                protected override void OnBackColorChanged (EventArgs e)
                {
                        base.OnBackColorChanged(e);
                }
                
                protected override void OnFontChanged (EventArgs e)
                {
                        base.OnFontChanged(e);
                }
                
                protected override void OnForeColorChanged (EventArgs e)
                {
                        base.OnForeColorChanged(e);
                }
                
                protected override void OnHandleCreated (EventArgs e)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                protected virtual void OnInPlaceActive ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected override void OnLostFocus (EventArgs e)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                protected override bool ProcessDialogKey (Keys keyData)
                {
                        return base.ProcessDialogKey(keyData);
                }

                protected override bool ProcessMnemonic (char charCode)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected bool PropsValid ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented"); 
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseDown (short button, short shift, int x, int y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseDown (short button, short shift, float x, float y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseDown (object o1, object o2, object o3, object o4)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseMove (short button, short shift, int x, int y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseMove (short button, short shift, float x, float y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseMove (object o1, object o2, object o3, object o4)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseUp (short button, short shift, int x, int y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseUp (short button, short shift, float x, float y)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                [EditorBrowsable (EditorBrowsableState.Advanced)]
                protected void RaiseOnMouseUp (object o1, object o2, object o3, object o4)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }

                protected void SetAboutBoxDelegate (AxHost.AboutBoxDelegate d)
                {
                        this.aboutDelegate = d;
                }
                
                protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
                {
                        base.SetBoundsCore(x, y, width, height, specified);
                }
                
                protected override void SetVisibleCore (bool value)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                protected override void WndProc (ref Message m)
                {
                        this.DefWndProc(ref m);
                }
                #endregion      // Protected Instance Methods

                #region Events
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler BackColorChanged {
                        add { throw new NotSupportedException("BackColorChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler BackgroundImageChanged {
                        add { throw new NotSupportedException("BackgroundImageChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler BindingContextChanged {
                        add { throw new NotSupportedException("BackgroundImageChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event UICuesEventHandler ChangeUICues {
                        add { throw new NotSupportedException("ChangeUICues"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler Click {
                        add { throw new NotSupportedException("Click"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler ContextMenuChanged {
                        add { throw new NotSupportedException("ContextMenuChanged"); }
                        remove { }
                }
        
                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler CursorChanged {
                        add { throw new NotSupportedException("CursorChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler DoubleClick {
                        add { throw new NotSupportedException("DoubleClick"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event DragEventHandler DragDrop {
                        add { throw new NotSupportedException("DragDrop"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event DragEventHandler DragEnter {
                        add { throw new NotSupportedException("DragEnter"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler DragLeave {
                        add { throw new NotSupportedException("DragLeave"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event DragEventHandler DragOver {
                        add { throw new NotSupportedException("DragOver"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler EnabledChanged {
                        add { throw new NotSupportedException("EnabledChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler FontChanged {
                        add { throw new NotSupportedException("FontChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler ForeColorChanged {
                        add { throw new NotSupportedException("ForeColorChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event GiveFeedbackEventHandler GiveFeedback {
                        add { throw new NotSupportedException("GiveFeedback"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event HelpEventHandler HelpRequested {
                        add { throw new NotSupportedException("HelpRequested"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler ImeModeChanged {
                        add { throw new NotSupportedException("ImeModeChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event KeyEventHandler KeyDown {
                        add { throw new NotSupportedException("KeyDown"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event KeyPressEventHandler KeyPress {
                        add { throw new NotSupportedException("KeyPress"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event KeyEventHandler KeyUp {
                        add { throw new NotSupportedException("KeyUp"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event LayoutEventHandler Layout {
                        add { throw new NotSupportedException("Layout"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event MouseEventHandler MouseDown {
                        add { throw new NotSupportedException("MouseDown"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler MouseEnter {
                        add { throw new NotSupportedException("MouseEnter"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler MouseHover {
                        add { throw new NotSupportedException("MouseHover"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler MouseLeave {
                        add { throw new NotSupportedException("MouseLeave"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event MouseEventHandler MouseMove {
                        add { throw new NotSupportedException("MouseMove"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event MouseEventHandler MouseUp {
                        add { throw new NotSupportedException("MouseUp"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event MouseEventHandler MouseWheel {
                        add { throw new NotSupportedException("MouseWheel"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event PaintEventHandler Paint {
                        add { throw new NotSupportedException("Paint"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
                        add { throw new NotSupportedException("QueryAccessibilityHelp"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event QueryContinueDragEventHandler QueryContinueDrag {
                        add { throw new NotSupportedException("QueryContinueDrag"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler RightToLeftChanged {
                        add { throw new NotSupportedException("RightToLeftChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler StyleChanged {
                        add { throw new NotSupportedException("StyleChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler BackgroundImageLayoutChanged {
                        add { throw new NotSupportedException("BackgroundImageChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler MouseClick {
                        add { throw new NotSupportedException("BackgroundImMouseClickageChanged"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler MouseDoubleClick {
                        add { throw new NotSupportedException("MouseDoubleClick"); }
                        remove { }
                }

                [Browsable (false)]
                [EditorBrowsable (EditorBrowsableState.Never)]
                public new event EventHandler TextChanged {
                        add { throw new NotSupportedException("TextChanged"); }
                        remove { }
                }
                #endregion      // Events

                #region Delegates
                protected delegate void AboutBoxDelegate ();
                #endregion      // Delegates

                #region Interfaces
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                AttributeCollection ICustomTypeDescriptor.GetAttributes ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                string ICustomTypeDescriptor.GetClassName ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                string ICustomTypeDescriptor.GetComponentName ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                TypeConverter ICustomTypeDescriptor.GetConverter ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                EventDescriptor ICustomTypeDescriptor.GetDefaultEvent ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                object ICustomTypeDescriptor.GetEditor (Type editorBaseType)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                EventDescriptorCollection ICustomTypeDescriptor.GetEvents ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                EventDescriptorCollection ICustomTypeDescriptor.GetEvents (Attribute[] attributes)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties ()
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties (Attribute[] attributes)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                
                [EditorBrowsable (EditorBrowsableState.Advanced)]
                object ICustomTypeDescriptor.GetPropertyOwner (PropertyDescriptor pd)
                {
                        throw new NotImplementedException("COM/ActiveX support is not implemented");
                }
                #endregion      // Interfaces

                internal static bool IsRunningOnWindows {
                        get { return runningOnWindows; }
                }

                static Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046");

                [DllImport("ole32.dll")]
                static extern int CoCreateInstance (
                        [In] ref Guid rclsid,
                        [In, MarshalAs (UnmanagedType.IUnknown)] object pUnkOuter,
                        [In] uint dwClsContext,
                        [In] ref Guid riid,
                        [Out, MarshalAs (UnmanagedType.Interface)] out object ppv);

        }
}