Use ComWrappers for Clipboard

src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.AgileReferenceOptions.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class Ole32
+    {
+        public enum AgileReferenceOptions
+        {
+            Default = 0,
+            DelayedMarshal = 1,
+        }
+    }
+}

src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.OleGetClipboard.cs

@@ -2,14 +2,31 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 
 internal static partial class Interop
 {
     internal static partial class Ole32
     {
+        [DllImport(Libraries.Ole32, ExactSpelling = true)]
+        private static extern HRESULT OleGetClipboard(out IntPtr data);
+
         [DllImport(Libraries.Ole32, ExactSpelling = true)]
         public static extern HRESULT OleGetClipboard(ref IDataObject? data);
+
+        public static bool TryOleGetClipboard(out HRESULT result, [NotNullWhen(true)] out IDataObject? data)
+        {
+            result = OleGetClipboard(out IntPtr ptr);
+            if (result == HRESULT.S_OK)
+            {
+                data = (IDataObject)WinFormsComWrappers.Instance.GetOrCreateObjectForComInstance(ptr, CreateObjectFlags.Unwrap);
+                return true;
+            }
+
+            data = null;
+            return false;
+        }
     }
 }

src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.OleSetClipboard.cs

@@ -10,6 +10,16 @@ internal static partial class Interop
     internal static partial class Ole32
     {
         [DllImport(Libraries.Ole32, ExactSpelling = true)]
-        public static extern HRESULT OleSetClipboard(IDataObject? pDataObj);
+        private static extern HRESULT OleSetClipboard(IntPtr pDataObj);
+
+        public static HRESULT OleSetClipboard(IDataObject? pDataObj)
+        {
+            if (pDataObj is null)
+            {
+                return OleSetClipboard(IntPtr.Zero);
+            }
+
+            return OleSetClipboard(WinFormsComWrappers.Instance.GetComPointer(pDataObj, IID.IDataObject));
+        }
     }
 }

src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.RoGetAgileReference.cs

@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Ole32
+    {
+        [DllImport(Libraries.Ole32, ExactSpelling = true)]
+        public static extern HRESULT RoGetAgileReference(
+            AgileReferenceOptions opts,
+            ref Guid riid,
+            IntPtr instance,
+            out IntPtr agileReference);
+
+        public static WinFormsComWrappers.AgileReferenceWrapper RoGetAgileReference(AgileReferenceOptions opts, ref Guid riid, IntPtr instance)
+        {
+            RoGetAgileReference(opts, ref riid, instance, out var agileReference);
+            return new WinFormsComWrappers.AgileReferenceWrapper(agileReference);
+        }
+    }
+}

src/System.Windows.Forms.Primitives/src/Interop/WinFormsComWrappers.AgileDataObjectWrapper.cs

@@ -0,0 +1,81 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices.ComTypes;
+
+internal partial class Interop
+{
+    internal unsafe partial class WinFormsComWrappers
+    {
+        internal class AgileDataObjectWrapper : IDataObject
+        {
+            private AgileReferenceWrapper _wrappedInstance;
+
+            public AgileDataObjectWrapper(AgileReferenceWrapper wrappedInstance)
+            {
+                _wrappedInstance = wrappedInstance;
+            }
+
+            private DataObjectWrapper Unwrap()
+            {
+                var instance = _wrappedInstance.Resolve(IID.IDataObject);
+                return new DataObjectWrapper(instance);
+            }
+
+            public void GetData(ref FORMATETC format, out STGMEDIUM medium)
+            {
+                using var dataObject = Unwrap();
+                dataObject.GetData(ref format, out medium);
+            }
+
+            public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium)
+            {
+                using var dataObject = Unwrap();
+                dataObject.GetDataHere(ref format, ref medium);
+            }
+
+            public int QueryGetData(ref FORMATETC format)
+            {
+                using var dataObject = Unwrap();
+                return dataObject.QueryGetData(ref format);
+            }
+
+            public int GetCanonicalFormatEtc(ref FORMATETC formatIn, out FORMATETC formatOut)
+            {
+                using var dataObject = Unwrap();
+                return dataObject.GetCanonicalFormatEtc(ref formatIn, out formatOut);
+            }
+
+            public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release)
+            {
+                using var dataObject = Unwrap();
+                dataObject.SetData(ref formatIn, ref medium, release);
+            }
+
+            public IEnumFORMATETC EnumFormatEtc(DATADIR direction)
+            {
+                using var dataObject = Unwrap();
+                return dataObject.EnumFormatEtc(direction);
+            }
+
+            public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection)
+            {
+                using var dataObject = Unwrap();
+                return dataObject.DAdvise(ref pFormatetc, advf, adviseSink, out connection);
+            }
+
+            public void DUnadvise(int connection)
+            {
+                using var dataObject = Unwrap();
+                dataObject.DUnadvise(connection);
+            }
+
+            public int EnumDAdvise(out IEnumSTATDATA? enumAdvise)
+            {
+                using var dataObject = Unwrap();
+                return dataObject.EnumDAdvise(out enumAdvise);
+            }
+        }
+    }
+}

src/System.Windows.Forms.Primitives/src/Interop/WinFormsComWrappers.AgileReferenceWrapper.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+internal partial class Interop
+{
+    internal unsafe partial class WinFormsComWrappers
+    {
+        internal class AgileReferenceWrapper
+        {
+            private IntPtr _wrappedInstance;
+
+            public AgileReferenceWrapper(IntPtr wrappedInstance)
+            {
+                _wrappedInstance = wrappedInstance.OrThrowIfZero();
+            }
+
+            internal IntPtr Instance => _wrappedInstance;
+
+            ~AgileReferenceWrapper()
+            {
+                Marshal.Release(_wrappedInstance);
+                _wrappedInstance = IntPtr.Zero;
+            }
+
+            public unsafe IntPtr Resolve(Guid iid)
+            {
+                IntPtr result = IntPtr.Zero;
+                ((delegate* unmanaged<IntPtr, Guid*, IntPtr*, HRESULT>)(*(*(void***)_wrappedInstance + 3)))
+                    (_wrappedInstance, &iid, &result).ThrowIfFailed();
+                return result;
+            }
+        }
+    }
+}

src/System.Windows.Forms.Primitives/src/Interop/WinFormsComWrappers.DataObjectWrapper.cs

@@ -0,0 +1,167 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Windows.Forms;
+
+internal partial class Interop
+{
+    internal unsafe partial class WinFormsComWrappers
+    {
+        internal sealed class DataObjectWrapper : IDataObject, IDisposable
+        {
+            private IntPtr _wrappedInstance;
+
+            public DataObjectWrapper(IntPtr wrappedInstance)
+            {
+                _wrappedInstance = wrappedInstance.OrThrowIfZero();
+            }
+
+            internal IntPtr Instance => _wrappedInstance;
+
+            ~DataObjectWrapper()
+            {
+                this.DisposeInternal();
+            }
+
+            public void Dispose()
+            {
+                DisposeInternal();
+                GC.SuppressFinalize(this);
+            }
+
+            private void DisposeInternal()
+            {
+                Marshal.Release(_wrappedInstance);
+                _wrappedInstance = IntPtr.Zero;
+            }
+
+            public void GetData(ref FORMATETC format, out STGMEDIUM medium)
+            {
+                fixed (FORMATETC* formatPtr = &format)
+                {
+                    STGMEDIUM_Raw mediumRaw;
+                    ((delegate* unmanaged<IntPtr, FORMATETC*, STGMEDIUM_Raw*, HRESULT>)(*(*(void***)_wrappedInstance + 3)))
+                        (_wrappedInstance, formatPtr, &mediumRaw).ThrowIfFailed();
+                    medium = new()
+                    {
+                        pUnkForRelease = mediumRaw.pUnkForRelease == IntPtr.Zero ? null : Marshal.GetObjectForIUnknown(mediumRaw.pUnkForRelease),
+                        tymed = mediumRaw.tymed,
+                        unionmember = mediumRaw.unionmember,
+                    };
+                    if (mediumRaw.pUnkForRelease != IntPtr.Zero)
+                    {
+                        Marshal.Release(mediumRaw.pUnkForRelease);
+                    }
+                }
+            }
+
+            public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium)
+            {
+                fixed (FORMATETC* formatPtr = &format)
+                {
+                    STGMEDIUM_Raw mediumRaw = new()
+                    {
+                        pUnkForRelease = medium.pUnkForRelease is null ? IntPtr.Zero : Marshal.GetIUnknownForObject(medium.pUnkForRelease),
+                        tymed = medium.tymed,
+                        unionmember = medium.unionmember,
+                    };
+                    ((delegate* unmanaged<IntPtr, FORMATETC*, STGMEDIUM_Raw*, HRESULT>)(*(*(void***)_wrappedInstance + 4)))
+                        (_wrappedInstance, formatPtr, &mediumRaw).ThrowIfFailed();
+                    // Because we do not know if COM interface implementation change value of mediumRaw.pUnkForRelease during the call,
+                    // unmarshal it again.
+                    medium = new()
+                    {
+                        pUnkForRelease = mediumRaw.pUnkForRelease == IntPtr.Zero ? null : Marshal.GetObjectForIUnknown(mediumRaw.pUnkForRelease),
+                        tymed = mediumRaw.tymed,
+                        unionmember = mediumRaw.unionmember,
+                    };
+                    if (mediumRaw.pUnkForRelease != IntPtr.Zero)
+                    {
+                        Marshal.Release(mediumRaw.pUnkForRelease);
+                    }
+                }
+            }
+
+            public int QueryGetData(ref FORMATETC format)
+            {
+                fixed (FORMATETC* formatPtr = &format)
+                {
+                    return (int)((delegate* unmanaged<IntPtr, FORMATETC*, HRESULT>)(*(*(void***)_wrappedInstance + 5)))
+                        (_wrappedInstance, formatPtr);
+                }
+            }
+
+            public int GetCanonicalFormatEtc(ref FORMATETC formatIn, out FORMATETC formatOut)
+            {
+                fixed (FORMATETC* formatInPtr = &formatIn)
+                fixed (FORMATETC* formatOutPtr = &formatOut)
+                {
+                    return (int)((delegate* unmanaged<IntPtr, FORMATETC*, FORMATETC*, HRESULT>)(*(*(void***)_wrappedInstance + 6)))
+                        (_wrappedInstance, formatInPtr, formatOutPtr);
+                }
+            }
+
+            public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release)
+            {
+                fixed (FORMATETC* formatInPtr = &formatIn)
+                {
+                    STGMEDIUM_Raw mediumRaw = new()
+                    {
+                        pUnkForRelease = medium.pUnkForRelease is null ? IntPtr.Zero : Marshal.GetIUnknownForObject(medium.pUnkForRelease),
+                        tymed = medium.tymed,
+                        unionmember = medium.unionmember,
+                    };
+                    ((delegate* unmanaged<IntPtr, FORMATETC*, STGMEDIUM_Raw*, int, HRESULT>)(*(*(void***)_wrappedInstance + 7)))
+                        (_wrappedInstance, formatInPtr, &mediumRaw, release ? 1 : 0).ThrowIfFailed();
+                    medium = new()
+                    {
+                        pUnkForRelease = mediumRaw.pUnkForRelease == IntPtr.Zero ? null : Marshal.GetObjectForIUnknown(mediumRaw.pUnkForRelease),
+                        tymed = mediumRaw.tymed,
+                        unionmember = mediumRaw.unionmember,
+                    };
+                    if (mediumRaw.pUnkForRelease != IntPtr.Zero)
+                    {
+                        Marshal.Release(mediumRaw.pUnkForRelease);
+                    }
+                }
+            }
+
+            public IEnumFORMATETC EnumFormatEtc(DATADIR direction)
+            {
+                IntPtr resultPtr;
+                ((delegate* unmanaged<IntPtr, DATADIR, IntPtr*, HRESULT>)(*(*(void***)_wrappedInstance + 8)))
+                    (_wrappedInstance, direction, &resultPtr).ThrowIfFailed();
+                return (IEnumFORMATETC)WinFormsComWrappers.Instance.GetOrCreateObjectForComInstance(resultPtr, CreateObjectFlags.Unwrap);
+            }
+
+            public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection)
+            {
+                fixed (FORMATETC* formatPtr = &pFormatetc)
+                fixed (int* connectionPtr = &connection)
+                {
+                    var adviseSinkPtr = WinFormsComWrappers.Instance.GetOrCreateComInterfaceForObject(adviseSink, CreateComInterfaceFlags.None);
+                    return (int)((delegate* unmanaged<IntPtr, FORMATETC*, ADVF, IntPtr, int*, HRESULT>)(*(*(void***)_wrappedInstance + 9)))
+                        (_wrappedInstance, formatPtr, advf, adviseSinkPtr, connectionPtr);
+                }
+            }
+
+            public void DUnadvise(int connection)
+            {
+                ((delegate* unmanaged<IntPtr, int, HRESULT>)(*(*(void***)_wrappedInstance + 10)))
+                    (_wrappedInstance, connection).ThrowIfFailed();
+            }
+
+            public int EnumDAdvise(out IEnumSTATDATA? enumAdvise)
+            {
+                IntPtr enumAdvisePtr;
+                var result = ((delegate* unmanaged<IntPtr, IntPtr*, HRESULT>)(*(*(void***)_wrappedInstance + 11)))
+                    (_wrappedInstance, &enumAdvisePtr);
+                enumAdvise = result.Succeeded() ? null : (IEnumSTATDATA)Marshal.GetObjectForIUnknown(enumAdvisePtr);
+                return (int)result;
+            }
+        }
+    }
+}