Adjust project structure

src/Shared/HandyControl_Shared/Tools/Interop/BITMAPINFO.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace HandyControl.Tools.Interop
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 2)]
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal struct BITMAPINFO
+    {
+        public int bmiHeader_biSize;
+
+        public int bmiHeader_biWidth;
+
+        public int bmiHeader_biHeight;
+
+        public short bmiHeader_biPlanes;
+
+        public short bmiHeader_biBitCount;
+
+        public int bmiHeader_biCompression;
+
+        public int bmiHeader_biSizeImage;
+
+        public int bmiHeader_biXPelsPerMeter;
+
+        public int bmiHeader_biYPelsPerMeter;
+
+        public int bmiHeader_biClrUsed;
+
+        public int bmiHeader_biClrImportant;
+
+        public BITMAPINFO(int width, int height, short bpp)
+        {
+            bmiHeader_biSize = SizeOf();
+            bmiHeader_biWidth = width;
+            bmiHeader_biHeight = height;
+            bmiHeader_biPlanes = 1;
+            bmiHeader_biBitCount = bpp;
+            bmiHeader_biCompression = 0;
+            bmiHeader_biSizeImage = 0;
+            bmiHeader_biXPelsPerMeter = 0;
+            bmiHeader_biYPelsPerMeter = 0;
+            bmiHeader_biClrUsed = 0;
+            bmiHeader_biClrImportant = 0;
+        }
+
+        [SecuritySafeCritical]
+        private static int SizeOf()
+        {
+            return Marshal.SizeOf(typeof(BITMAPINFO));
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/BitmapHandle.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace HandyControl.Tools.Interop
+{
+    [SuppressMessage("ReSharper", "UnusedMember.Local")]
+    internal sealed class BitmapHandle : WpfSafeHandle
+    {
+        [SecurityCritical]
+        private BitmapHandle() : this(true)
+        {
+            //请不要删除此构造函数，否则当使用自定义ico文件时会报错
+        }
+
+        [SecurityCritical]
+        private BitmapHandle(bool ownsHandle) : base(ownsHandle, CommonHandles.GDI)
+        {
+        }
+
+        [SecurityCritical]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected override bool ReleaseHandle()
+        {
+            return UnsafeNativeMethods.DeleteObject(handle);
+        }
+
+        [SecurityCritical]
+        internal HandleRef MakeHandleRef(object obj)
+        {
+            return new HandleRef(obj, handle);
+        }
+
+        [SecurityCritical]
+        internal static BitmapHandle CreateFromHandle(IntPtr hbitmap, bool ownsHandle = true)
+        {
+            return new BitmapHandle(ownsHandle)
+            {
+                handle = hbitmap,
+            };
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/CommonHandles.cs

@@ -0,0 +1,16 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace HandyControl.Tools.Interop
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal static class CommonHandles
+    {
+        public static readonly int Icon = HandleCollector.RegisterType(nameof(Icon), 20, 500);
+
+        public static readonly int HDC = HandleCollector.RegisterType(nameof(HDC), 100, 2);
+
+        public static readonly int GDI = HandleCollector.RegisterType(nameof(GDI), 50, 500);
+
+        public static readonly int Kernel = HandleCollector.RegisterType(nameof(Kernel), 0, 1000);
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/ExternDll.cs

@@ -0,0 +1,11 @@
+namespace HandyControl.Tools.Interop
+{
+    internal static class ExternDll
+    {
+        public const string
+            User32 = "user32.dll",
+            Gdi32 = "gdi32.dll",
+            Kernel32 = "kernel32.dll",
+            Shell32 = "shell32.dll";
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/HandleCollector.cs

@@ -0,0 +1,132 @@
+// reference from https://referencesource.microsoft.com/#WindowsBase/Shared/MS/Win32/HandleCollector.cs,d0f99220d8e1b708
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace HandyControl.Tools.Interop
+{
+    internal static class HandleCollector
+    {
+        private static HandleType[] HandleTypes;
+        private static int HandleTypeCount;
+
+        private static readonly object HandleMutex = new object();
+
+        internal static IntPtr Add(IntPtr handle, int type)
+        {
+            HandleTypes[type - 1].Add();
+            return handle;
+        }
+
+        [System.Security.SecuritySafeCritical]
+        internal static SafeHandle Add(SafeHandle handle, int type)
+        {
+            HandleTypes[type - 1].Add();
+            return handle;
+        }
+
+        internal static void Add(int type)
+        {
+            HandleTypes[type - 1].Add();
+        }
+
+        internal static int RegisterType(string typeName, int expense, int initialThreshold)
+        {
+            lock (HandleMutex)
+            {
+                if (HandleTypeCount == 0 || HandleTypeCount == HandleTypes.Length)
+                {
+                    HandleType[] newTypes = new HandleType[HandleTypeCount + 10];
+                    if (HandleTypes != null)
+                    {
+                        Array.Copy(HandleTypes, 0, newTypes, 0, HandleTypeCount);
+                    }
+                    HandleTypes = newTypes;
+                }
+
+                HandleTypes[HandleTypeCount++] = new HandleType(expense, initialThreshold);
+                return HandleTypeCount;
+            }
+        }
+
+        internal static IntPtr Remove(IntPtr handle, int type)
+        {
+            HandleTypes[type - 1].Remove();
+            return handle;
+        }
+
+        [System.Security.SecuritySafeCritical]
+        internal static SafeHandle Remove(SafeHandle handle, int type)
+        {
+            HandleTypes[type - 1].Remove();
+            return handle;
+        }
+
+        internal static void Remove(int type)
+        {
+            HandleTypes[type - 1].Remove();
+        }
+
+        private class HandleType
+        {
+            private readonly int _initialThreshHold;
+            private int _threshHold;
+            private int _handleCount;
+            private readonly int _deltaPercent;
+
+            internal HandleType(int expense, int initialThreshHold)
+            {
+                _initialThreshHold = initialThreshHold;
+                _threshHold = initialThreshHold;
+                _deltaPercent = 100 - expense;
+            }
+
+            internal void Add()
+            {
+                lock (this)
+                {
+                    _handleCount++;
+                    var performCollect = NeedCollection();
+
+                    if (!performCollect)
+                    {
+                        return;
+                    }
+                }
+
+                GC.Collect();
+
+                var sleep = (100 - _deltaPercent) / 4;
+                System.Threading.Thread.Sleep(sleep);
+            }
+
+            private bool NeedCollection()
+            {
+
+                if (_handleCount > _threshHold)
+                {
+                    _threshHold = _handleCount + _handleCount * _deltaPercent / 100;
+                    return true;
+                }
+
+                var oldThreshHold = 100 * _threshHold / (100 + _deltaPercent);
+                if (oldThreshHold >= _initialThreshHold && _handleCount < (int)(oldThreshHold * .9F))
+                {
+                    _threshHold = oldThreshHold;
+                }
+
+                return false;
+            }
+
+            internal void Remove()
+            {
+                lock (this)
+                {
+                    _handleCount--;
+
+                    _handleCount = Math.Max(0, _handleCount);
+                }
+            }
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/ICONINFO.cs

@@ -0,0 +1,16 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace HandyControl.Tools.Interop
+{
+    [StructLayout(LayoutKind.Sequential)]
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal class ICONINFO
+    {
+        public bool fIcon = false;
+        public int xHotspot = 0;
+        public int yHotspot = 0;
+        public BitmapHandle hbmMask = null;
+        public BitmapHandle hbmColor = null;
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/IconHandle.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using System.Security;
+
+namespace HandyControl.Tools.Interop
+{
+    internal sealed class IconHandle : WpfSafeHandle
+    {
+        [SecurityCritical]
+        private IconHandle() : base(true, CommonHandles.Icon)
+        {
+        }
+
+        [SecurityCritical]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+        protected override bool ReleaseHandle()
+        {
+            return UnsafeNativeMethods.DestroyIcon(handle);
+        }
+
+        [SecurityCritical, SecuritySafeCritical]
+        internal static IconHandle GetInvalidIcon()
+        {
+            return new IconHandle();
+        }
+
+        [SecurityCritical]
+        internal IntPtr CriticalGetHandle()
+        {
+            return handle;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/NOTIFYICONDATA.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace HandyControl.Tools.Interop
+{
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    public class NOTIFYICONDATA
+    {
+        public int cbSize = Marshal.SizeOf(typeof(NOTIFYICONDATA));
+        public IntPtr hWnd;
+        public int uID;
+        public int uFlags;
+        public int uCallbackMessage;
+        public IntPtr hIcon;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+        public string szTip = string.Empty;
+        public int dwState = 0x01;
+        public int dwStateMask = 0x01;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string szInfo = string.Empty;
+        public int uTimeoutOrVersion;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+        public string szInfoTitle = string.Empty;
+        public int dwInfoFlags;
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/NativeMethods.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+namespace HandyControl.Tools.Interop
+{
+    public delegate IntPtr WndProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    [SuppressMessage("ReSharper", "IdentifierTypo")]
+    internal class NativeMethods
+    {
+        public const int
+            WS_CHILD = 0x40000000,
+            BITSPIXEL = 12,
+            PLANES = 14,
+            BI_RGB = 0,
+            DIB_RGB_COLORS = 0,
+            NIF_MESSAGE = 0x00000001,
+            NIF_ICON = 0x00000002,
+            NIF_TIP = 0x00000004,
+            NIF_INFO = 0x00000010,
+            NIN_BALLOONSHOW = WM_USER + 2,
+            NIN_BALLOONHIDE = WM_USER + 3,
+            NIN_BALLOONTIMEOUT = WM_USER + 4,
+            NIM_ADD = 0x00000000,
+            NIM_MODIFY = 0x00000001,
+            NIM_DELETE = 0x00000002,
+            NIIF_NONE = 0x00000000,
+            NIIF_INFO = 0x00000001,
+            NIIF_WARNING = 0x00000002,
+            NIIF_ERROR = 0x00000003,
+            WM_MOUSEMOVE = 0x0200,
+            WM_LBUTTONDOWN = 0x0201,
+            WM_LBUTTONUP = 0x0202,
+            WM_LBUTTONDBLCLK = 0x0203,
+            WM_RBUTTONDOWN = 0x0204,
+            WM_RBUTTONUP = 0x0205,
+            WM_RBUTTONDBLCLK = 0x0206,
+            WM_MBUTTONDOWN = 0x0207,
+            WM_MBUTTONUP = 0x0208,
+            WM_MBUTTONDBLCLK = 0x0209,
+            WM_USER = 0x0400;
+
+        [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+        [ResourceExposure(ResourceScope.None)]
+        public static extern int RegisterWindowMessage(string msg);
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/NativeValues.cs

@@ -0,0 +1,119 @@
+// ReSharper disable InconsistentNaming
+
+using System.Runtime.InteropServices;
+
+namespace HandyControl.Tools.Interop
+{
+    internal enum SM
+    {
+        CXSCREEN = 0,
+        CYSCREEN = 1,
+        CXVSCROLL = 2,
+        CYHSCROLL = 3,
+        CYCAPTION = 4,
+        CXBORDER = 5,
+        CYBORDER = 6,
+        CXFIXEDFRAME = 7,
+        CYFIXEDFRAME = 8,
+        CYVTHUMB = 9,
+        CXHTHUMB = 10,
+        CXICON = 11,
+        CYICON = 12,
+        CXCURSOR = 13,
+        CYCURSOR = 14,
+        CYMENU = 15,
+        CXFULLSCREEN = 16,
+        CYFULLSCREEN = 17,
+        CYKANJIWINDOW = 18,
+        MOUSEPRESENT = 19,
+        CYVSCROLL = 20,
+        CXHSCROLL = 21,
+        DEBUG = 22,
+        SWAPBUTTON = 23,
+        CXMIN = 28,
+        CYMIN = 29,
+        CXSIZE = 30,
+        CYSIZE = 31,
+        CXFRAME = 32,
+        CXSIZEFRAME = CXFRAME,
+        CYFRAME = 33,
+        CYSIZEFRAME = CYFRAME,
+        CXMINTRACK = 34,
+        CYMINTRACK = 35,
+        CXDOUBLECLK = 36,
+        CYDOUBLECLK = 37,
+        CXICONSPACING = 38,
+        CYICONSPACING = 39,
+        MENUDROPALIGNMENT = 40,
+        PENWINDOWS = 41,
+        DBCSENABLED = 42,
+        CMOUSEBUTTONS = 43,
+        SECURE = 44,
+        CXEDGE = 45,
+        CYEDGE = 46,
+        CXMINSPACING = 47,
+        CYMINSPACING = 48,
+        CXSMICON = 49,
+        CYSMICON = 50,
+        CYSMCAPTION = 51,
+        CXSMSIZE = 52,
+        CYSMSIZE = 53,
+        CXMENUSIZE = 54,
+        CYMENUSIZE = 55,
+        ARRANGE = 56,
+        CXMINIMIZED = 57,
+        CYMINIMIZED = 58,
+        CXMAXTRACK = 59,
+        CYMAXTRACK = 60,
+        CXMAXIMIZED = 61,
+        CYMAXIMIZED = 62,
+        NETWORK = 63,
+        CLEANBOOT = 67,
+        CXDRAG = 68,
+        CYDRAG = 69,
+        SHOWSOUNDS = 70,
+        CXMENUCHECK = 71,
+        CYMENUCHECK = 72,
+        SLOWMACHINE = 73,
+        MIDEASTENABLED = 74,
+        MOUSEWHEELPRESENT = 75,
+        XVIRTUALSCREEN = 76,
+        YVIRTUALSCREEN = 77,
+        CXVIRTUALSCREEN = 78,
+        CYVIRTUALSCREEN = 79,
+        CMONITORS = 80,
+        SAMEDISPLAYFORMAT = 81,
+        IMMENABLED = 82,
+        CXFOCUSBORDER = 83,
+        CYFOCUSBORDER = 84,
+        TABLETPC = 86,
+        MEDIACENTER = 87,
+        REMOTESESSION = 0x1000,
+        REMOTECONTROL = 0x2001,
+    }
+
+    internal static class Win32Constant
+    {
+        internal const int MAX_PATH = 260;
+        internal const int INFOTIPSIZE = 1024;
+        internal const int TRUE = 1;
+        internal const int FALSE = 0;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public class POINT
+    {
+        public int x;
+        public int y;
+
+        public POINT()
+        {
+        }
+
+        public POINT(int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/SafeFileMappingHandle.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.Permissions;
+using Microsoft.Win32.SafeHandles;
+
+namespace HandyControl.Tools.Interop
+{
+    internal sealed class SafeFileMappingHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        [SecurityCritical]
+        internal SafeFileMappingHandle(IntPtr handle) : base(false)
+        {
+            SetHandle(handle);
+        }
+
+        [SecurityCritical, SecuritySafeCritical]
+        internal SafeFileMappingHandle() : base(true)
+        {
+        }
+
+        public override bool IsInvalid
+        {
+            [SecurityCritical, SecuritySafeCritical]
+            get => handle == IntPtr.Zero;
+        }
+
+        [SecurityCritical, SecuritySafeCritical]
+        protected override bool ReleaseHandle()
+        {
+            new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
+            try
+            {
+                return CloseHandleNoThrow(new HandleRef(null, handle));
+            }
+            finally
+            {
+                CodeAccessPermission.RevertAssert();
+            }
+        }
+
+        [SecurityCritical]
+        public static bool CloseHandleNoThrow(HandleRef handle)
+        {
+            HandleCollector.Remove((IntPtr)handle, CommonHandles.Kernel);
+            var result = UnsafeNativeMethods.IntCloseHandle(handle);
+            return result;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/UnsafeNativeMethods.cs

@@ -0,0 +1,182 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security;
+using System.Text;
+
+namespace HandyControl.Tools.Interop
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal class UnsafeNativeMethods
+    {
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32, SetLastError = true, ExactSpelling = true, EntryPoint = nameof(GetDC), CharSet = CharSet.Auto)]
+        public static extern IntPtr IntGetDC(HandleRef hWnd);
+
+        [SecurityCritical]
+        public static IntPtr GetDC(HandleRef hWnd)
+        {
+            var hDc = IntGetDC(hWnd);
+            if (hDc == IntPtr.Zero)
+            {
+                throw new Win32Exception();
+            }
+
+            return HandleCollector.Add(hDc, CommonHandles.HDC);
+        }
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32, ExactSpelling = true, EntryPoint = nameof(ReleaseDC), CharSet = CharSet.Auto)]
+        public static extern int IntReleaseDC(HandleRef hWnd, HandleRef hDC);
+
+        [SecurityCritical]
+        public static int ReleaseDC(HandleRef hWnd, HandleRef hDC)
+        {
+            HandleCollector.Remove((IntPtr)hDC, CommonHandles.HDC);
+            return IntReleaseDC(hWnd, hDC);
+        }
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern int GetDeviceCaps(HandleRef hDC, int nIndex);
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32)]
+        public static extern int GetSystemMetrics(SM nIndex);
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32, EntryPoint = nameof(DestroyIcon), CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern bool IntDestroyIcon(IntPtr hIcon);
+
+        [SecurityCritical]
+        public static bool DestroyIcon(IntPtr hIcon)
+        {
+            var result = IntDestroyIcon(hIcon);
+            return result;
+        }
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Gdi32, EntryPoint = nameof(DeleteObject), CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern bool IntDeleteObject(IntPtr hObject);
+
+        [SecurityCritical]
+        public static bool DeleteObject(IntPtr hObject)
+        {
+            var result = IntDeleteObject(hObject);
+            return result;
+        }
+
+        [SecurityCritical]
+        public static BitmapHandle CreateDIBSection(HandleRef hdc, ref BITMAPINFO bitmapInfo, int iUsage, ref IntPtr ppvBits, SafeFileMappingHandle hSection, int dwOffset)
+        {
+            if (hSection == null)
+            {
+                hSection = new SafeFileMappingHandle(IntPtr.Zero);
+            }
+
+            var hBitmap = PrivateCreateDIBSection(hdc, ref bitmapInfo, iUsage, ref ppvBits, hSection, dwOffset);
+            return hBitmap;
+        }
+
+        [DllImport(ExternDll.Kernel32, EntryPoint = "CloseHandle", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern bool IntCloseHandle(HandleRef handle);
+
+        [SecurityCritical, SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = nameof(CreateDIBSection))]
+        private static extern BitmapHandle PrivateCreateDIBSection(HandleRef hdc, ref BITMAPINFO bitmapInfo, int iUsage, ref IntPtr ppvBits, SafeFileMappingHandle hSection, int dwOffset);
+
+        [SecurityCritical, SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = nameof(CreateIconIndirect))]
+        private static extern IconHandle PrivateCreateIconIndirect([In, MarshalAs(UnmanagedType.LPStruct)]ICONINFO iconInfo);
+
+        [SecurityCritical]
+        public static IconHandle CreateIconIndirect([In, MarshalAs(UnmanagedType.LPStruct)]ICONINFO iconInfo)
+        {
+            var hIcon = PrivateCreateIconIndirect(iconInfo);
+            return hIcon;
+        }
+
+        [SecurityCritical, SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = nameof(CreateBitmap))]
+        private static extern BitmapHandle PrivateCreateBitmap(int width, int height, int planes, int bitsPerPixel, byte[] lpvBits);
+
+        [SecurityCritical]
+        internal static BitmapHandle CreateBitmap(int width, int height, int planes, int bitsPerPixel, byte[] lpvBits)
+        {
+            var hBitmap = PrivateCreateBitmap(width, height, planes, bitsPerPixel, lpvBits);
+            return hBitmap;
+        }
+
+        [SecurityCritical, SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Kernel32, EntryPoint = "GetModuleFileName", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern int IntGetModuleFileName(HandleRef hModule, StringBuilder buffer, int length);
+
+        [SecurityCritical]
+        internal static string GetModuleFileName(HandleRef hModule)
+        {
+            var buffer = new StringBuilder(Win32Constant.MAX_PATH);
+            while (true)
+            {
+                var size = IntGetModuleFileName(hModule, buffer, buffer.Capacity);
+                if (size == 0)
+                {
+                    throw new Win32Exception();
+                }
+
+                if (size == buffer.Capacity)
+                {
+                    buffer.EnsureCapacity(buffer.Capacity * 2);
+                    continue;
+                }
+
+                return buffer.ToString();
+            }
+        }
+
+        [SecurityCritical, SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.Shell32, CharSet = CharSet.Auto, BestFitMapping = false, ThrowOnUnmappableChar = true)]
+        internal static extern int ExtractIconEx(string szExeFileName, int nIconIndex, out IconHandle phiconLarge, out IconHandle phiconSmall, int nIcons);
+
+        [DllImport(ExternDll.Shell32, CharSet = CharSet.Auto)]
+        public static extern int Shell_NotifyIcon(int message, NOTIFYICONDATA pnid);
+
+        [SecurityCritical]
+        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        [DllImport(ExternDll.User32, SetLastError = true, CharSet = CharSet.Unicode, EntryPoint = "CreateWindowExW")]
+        public static extern IntPtr CreateWindowEx(
+            int dwExStyle,
+            [MarshalAs(UnmanagedType.LPWStr)] string lpClassName,
+            [MarshalAs(UnmanagedType.LPWStr)] string lpWindowName,
+            int dwStyle,
+            int x,
+            int y,
+            int nWidth,
+            int nHeight,
+            IntPtr hWndParent,
+            IntPtr hMenu,
+            IntPtr hInstance,
+            IntPtr lpParam);
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(ExternDll.User32, CharSet = CharSet.Unicode, SetLastError = true, BestFitMapping = false)]
+        public static extern short RegisterClass(WNDCLASS wc);
+
+        [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+        public static extern IntPtr DefWindowProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool GetCursorPos([In, Out] POINT pt);
+
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool SetForegroundWindow(IntPtr hWnd);
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/WNDCLASS.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace HandyControl.Tools.Interop
+{
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    [SuppressMessage("ReSharper", "IdentifierTypo")]
+    internal class WNDCLASS
+    {
+        public int style;
+        public WndProc lpfnWndProc;
+        public int cbClsExtra;
+        public int cbWndExtra;
+        public IntPtr hInstance;
+        public IntPtr hIcon;
+        public IntPtr hCursor;
+        public IntPtr hbrBackground;
+        public string lpszMenuName;
+        public string lpszClassName;
+    }
+}

src/Shared/HandyControl_Shared/Tools/Interop/WpfSafeHandle.cs

@@ -0,0 +1,24 @@
+using System.Security;
+using Microsoft.Win32.SafeHandles;
+
+namespace HandyControl.Tools.Interop
+{
+    internal abstract class WpfSafeHandle : SafeHandleZeroOrMinusOneIsInvalid
+    {
+        private readonly int _collectorId;
+
+        [SecurityCritical]
+        protected WpfSafeHandle(bool ownsHandle, int collectorId) : base(ownsHandle)
+        {
+            HandleCollector.Add(collectorId);
+            _collectorId = collectorId;
+        }
+
+        [SecurityCritical, SecuritySafeCritical]
+        protected override void Dispose(bool disposing)
+        {
+            HandleCollector.Remove(_collectorId);
+            base.Dispose(disposing);
+        }
+    }
+}