Migrate files from Wox to PowerLauncher (#5014)

* Moved all files from Wox to Powerlauncher

* Removed Wox project

* Changed namespace for imported files

* Resolved errors for VM

* Added build dependency order

* Fixed errors in helper class

* Remove Wox files

* Fixed errors in SingleInstance class

* Fixed wox.tests

* Fixed MSI

* Removed obsolete methods from PublicAPI

* nit fixes

* Throw null exception

* Fix merge conflict

src/modules/launcher/PowerLauncher/Helper/DataWebRequestFactory.cs

@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using System.Net;
+
+namespace PowerLauncher.Helper
+{
+    public class DataWebRequestFactory : IWebRequestCreate
+    {
+        class DataWebRequest : WebRequest
+        {
+            private readonly Uri m_uri;
+
+            public DataWebRequest(Uri uri)
+            {
+                m_uri = uri;
+            }
+
+            public override WebResponse GetResponse()
+            {
+                return new DataWebResponse(m_uri);
+            }
+        }
+
+        class DataWebResponse : WebResponse
+        {
+            private readonly string m_contentType;
+            private readonly byte[] m_data;
+
+            public DataWebResponse(Uri uri)
+            {
+                string uriString = uri.AbsoluteUri;
+
+                int commaIndex = uriString.IndexOf(',', StringComparison.InvariantCultureIgnoreCase);
+                var headers = uriString.Substring(0, commaIndex).Split(';');
+                m_contentType = headers[0];
+                string dataString = uriString.Substring(commaIndex + 1);
+                m_data = Convert.FromBase64String(dataString);
+            }
+
+            public override string ContentType
+            {
+                get { return m_contentType; }
+                set
+                {
+                    throw new NotSupportedException();
+                }
+            }
+
+            public override long ContentLength
+            {
+                get { return m_data.Length; }
+                set
+                {
+                    throw new NotSupportedException();
+                }
+            }
+
+            public override Stream GetResponseStream()
+            {
+                return new MemoryStream(m_data);
+            }
+        }
+
+        public WebRequest Create(Uri uri)
+        {
+            return new DataWebRequest(uri);
+        }
+    }
+}

src/modules/launcher/PowerLauncher/Helper/ErrorReporting.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Windows.Threading;
+using NLog;
+using Wox.Infrastructure;
+using Wox.Infrastructure.Exception;
+
+namespace PowerLauncher.Helper
+{
+    public static class ErrorReporting
+    {
+        private static void Report(Exception e)
+        {
+            if( e != null)
+            {
+                var logger = LogManager.GetLogger("UnHandledException");
+                logger.Fatal(ExceptionFormatter.FormatException(e));
+
+                var reportWindow = new ReportWindow(e);
+                reportWindow.Show();
+            }           
+        }
+
+        public static void UnhandledExceptionHandle(object sender, UnhandledExceptionEventArgs e)
+        {
+            //handle non-ui thread exceptions
+            Report((Exception)e?.ExceptionObject);
+        }
+
+        public static void DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
+        {
+            //handle ui thread exceptions
+            Report(e?.Exception);
+            //prevent application exist, so the user can copy prompted error info
+            e.Handled = true;
+        }
+
+        public static string RuntimeInfo()
+        {
+            var info = $"\nVersion: {Constant.Version}" +
+                       $"\nOS Version: {Environment.OSVersion.VersionString}" +
+                       $"\nIntPtr Length: {IntPtr.Size}" +
+                       $"\nx64: {Environment.Is64BitOperatingSystem}";
+            return info;
+        }
+    }
+}

src/modules/launcher/PowerLauncher/Helper/KeyboardHelper.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Input;
+using Wox.Plugin;
+
+namespace PowerLauncher.Helper
+{
+    class KeyboardHelper
+    {
+        public static SpecialKeyState CheckModifiers()
+        {
+            SpecialKeyState state = new SpecialKeyState();
+            if ((Keyboard.GetKeyStates(Key.LeftShift) & KeyStates.Down) > 0 ||
+                (Keyboard.GetKeyStates(Key.RightShift) & KeyStates.Down) > 0)
+            {
+                state.ShiftPressed = true;
+            }
+            if ((Keyboard.GetKeyStates(Key.LWin) & KeyStates.Down) > 0 ||
+                (Keyboard.GetKeyStates(Key.RWin) & KeyStates.Down) > 0)
+            {
+                state.WinPressed = true;
+            }
+            if ((Keyboard.GetKeyStates(Key.LeftCtrl) & KeyStates.Down) > 0 ||
+                (Keyboard.GetKeyStates(Key.RightCtrl) & KeyStates.Down) > 0)
+            {
+                state.CtrlPressed = true;
+            }
+            if ((Keyboard.GetKeyStates(Key.LeftAlt) & KeyStates.Down) > 0 ||
+                (Keyboard.GetKeyStates(Key.RightAlt) & KeyStates.Down) > 0)
+            {
+                state.AltPressed = true;
+            }
+            return state;
+        }
+    }
+}

src/modules/launcher/PowerLauncher/Helper/ResultCollection.cs

@@ -0,0 +1,70 @@
+using PowerLauncher.ViewModel;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace PowerLauncher.Helper
+{
+    public class ResultCollection : ObservableCollection<ResultViewModel>
+    {
+
+        public void RemoveAll(Predicate<ResultViewModel> predicate)
+        {
+            CheckReentrancy();
+
+            for (int i = Count - 1; i >= 0; i--)
+            {
+                if (predicate(this[i]))
+                {
+                    RemoveAt(i);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update the results collection with new results, try to keep identical results
+        /// </summary>
+        /// <param name="newItems"></param>
+        public void Update(List<ResultViewModel> newItems)
+        {
+            if(newItems == null)
+            {
+                throw new ArgumentNullException(nameof(newItems));
+            }
+            
+            int newCount = newItems.Count;
+            int oldCount = Items.Count;
+            int location = newCount > oldCount ? oldCount : newCount;
+
+            for (int i = 0; i < location; i++)
+            {
+                ResultViewModel oldResult = this[i];
+                ResultViewModel newResult = newItems[i];
+                if (!oldResult.Equals(newResult))
+                { // result is not the same update it in the current index
+                    this[i] = newResult;
+                }
+                else if (oldResult.Result.Score != newResult.Result.Score)
+                {
+                    this[i].Result.Score = newResult.Result.Score;
+                }
+            }
+
+
+            if (newCount >= oldCount)
+            {
+                for (int i = oldCount; i < newCount; i++)
+                {
+                    Add(newItems[i]);
+                }
+            }
+            else
+            {
+                for (int i = oldCount - 1; i >= newCount; i--)
+                {
+                    RemoveAt(i);
+                }
+            }
+        }
+    }
+}

src/modules/launcher/PowerLauncher/Helper/SingleInstance.cs

@@ -0,0 +1,416 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.IO.Pipes;
+using System.Runtime.Serialization.Formatters;
+using System.Security;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Threading;
+using static PowerLauncher.Helper.WindowsInteropHelper;
+
+// http://blogs.microsoft.co.il/arik/2010/05/28/wpf-single-instance-application/
+// modified to allow single instance restart
+namespace PowerLauncher.Helper 
+{
+    internal enum WM
+    {
+        NULL = 0x0000,
+        CREATE = 0x0001,
+        DESTROY = 0x0002,
+        MOVE = 0x0003,
+        SIZE = 0x0005,
+        ACTIVATE = 0x0006,
+        SETFOCUS = 0x0007,
+        KILLFOCUS = 0x0008,
+        ENABLE = 0x000A,
+        SETREDRAW = 0x000B,
+        SETTEXT = 0x000C,
+        GETTEXT = 0x000D,
+        GETTEXTLENGTH = 0x000E,
+        PAINT = 0x000F,
+        CLOSE = 0x0010,
+        QUERYENDSESSION = 0x0011,
+        QUIT = 0x0012,
+        QUERYOPEN = 0x0013,
+        ERASEBKGND = 0x0014,
+        SYSCOLORCHANGE = 0x0015,
+        SHOWWINDOW = 0x0018,
+        ACTIVATEAPP = 0x001C,
+        SETCURSOR = 0x0020,
+        MOUSEACTIVATE = 0x0021,
+        CHILDACTIVATE = 0x0022,
+        QUEUESYNC = 0x0023,
+        GETMINMAXINFO = 0x0024,
+
+        WINDOWPOSCHANGING = 0x0046,
+        WINDOWPOSCHANGED = 0x0047,
+
+        CONTEXTMENU = 0x007B,
+        STYLECHANGING = 0x007C,
+        STYLECHANGED = 0x007D,
+        DISPLAYCHANGE = 0x007E,
+        GETICON = 0x007F,
+        SETICON = 0x0080,
+        NCCREATE = 0x0081,
+        NCDESTROY = 0x0082,
+        NCCALCSIZE = 0x0083,
+        NCHITTEST = 0x0084,
+        NCPAINT = 0x0085,
+        NCACTIVATE = 0x0086,
+        GETDLGCODE = 0x0087,
+        SYNCPAINT = 0x0088,
+        NCMOUSEMOVE = 0x00A0,
+        NCLBUTTONDOWN = 0x00A1,
+        NCLBUTTONUP = 0x00A2,
+        NCLBUTTONDBLCLK = 0x00A3,
+        NCRBUTTONDOWN = 0x00A4,
+        NCRBUTTONUP = 0x00A5,
+        NCRBUTTONDBLCLK = 0x00A6,
+        NCMBUTTONDOWN = 0x00A7,
+        NCMBUTTONUP = 0x00A8,
+        NCMBUTTONDBLCLK = 0x00A9,
+
+        SYSKEYDOWN = 0x0104,
+        SYSKEYUP = 0x0105,
+        SYSCHAR = 0x0106,
+        SYSDEADCHAR = 0x0107,
+        COMMAND = 0x0111,
+        SYSCOMMAND = 0x0112,
+
+        MOUSEMOVE = 0x0200,
+        LBUTTONDOWN = 0x0201,
+        LBUTTONUP = 0x0202,
+        LBUTTONDBLCLK = 0x0203,
+        RBUTTONDOWN = 0x0204,
+        RBUTTONUP = 0x0205,
+        RBUTTONDBLCLK = 0x0206,
+        MBUTTONDOWN = 0x0207,
+        MBUTTONUP = 0x0208,
+        MBUTTONDBLCLK = 0x0209,
+        MOUSEWHEEL = 0x020A,
+        XBUTTONDOWN = 0x020B,
+        XBUTTONUP = 0x020C,
+        XBUTTONDBLCLK = 0x020D,
+        MOUSEHWHEEL = 0x020E,
+
+
+        CAPTURECHANGED = 0x0215,
+
+        ENTERSIZEMOVE = 0x0231,
+        EXITSIZEMOVE = 0x0232,
+
+        IME_SETCONTEXT = 0x0281,
+        IME_NOTIFY = 0x0282,
+        IME_CONTROL = 0x0283,
+        IME_COMPOSITIONFULL = 0x0284,
+        IME_SELECT = 0x0285,
+        IME_CHAR = 0x0286,
+        IME_REQUEST = 0x0288,
+        IME_KEYDOWN = 0x0290,
+        IME_KEYUP = 0x0291,
+
+        NCMOUSELEAVE = 0x02A2,
+
+        DWMCOMPOSITIONCHANGED = 0x031E,
+        DWMNCRENDERINGCHANGED = 0x031F,
+        DWMCOLORIZATIONCOLORCHANGED = 0x0320,
+        DWMWINDOWMAXIMIZEDCHANGE = 0x0321,
+
+        #region Windows 7
+        DWMSENDICONICTHUMBNAIL = 0x0323,
+        DWMSENDICONICLIVEPREVIEWBITMAP = 0x0326,
+        #endregion
+
+        USER = 0x0400,
+
+        // This is the hard-coded message value used by WinForms for Shell_NotifyIcon.
+        // It's relatively safe to reuse.
+        TRAYMOUSEMESSAGE = 0x800, //WM_USER + 1024
+        APP = 0x8000
+    }
+
+    [SuppressUnmanagedCodeSecurity]
+    internal static class NativeMethods
+    {
+        /// <summary>
+        /// Delegate declaration that matches WndProc signatures.
+        /// </summary>
+        public delegate IntPtr MessageHandler(WM uMsg, IntPtr wParam, IntPtr lParam, out bool handled);
+
+        [DllImport("shell32.dll", EntryPoint = "CommandLineToArgvW", CharSet = CharSet.Unicode)]
+        private static extern IntPtr _CommandLineToArgvW([MarshalAs(UnmanagedType.LPWStr)] string cmdLine, out int numArgs);
+
+
+        [DllImport("kernel32.dll", EntryPoint = "LocalFree", SetLastError = true)]
+        internal static extern IntPtr _LocalFree(IntPtr hMem);
+
+        [DllImport("user32.dll")]
+        internal static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+
+        [DllImport("user32.dll")]
+        internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+
+        [DllImport("user32.dll")]
+        internal static extern IntPtr GetForegroundWindow();
+
+        [DllImport("user32.dll")]
+        internal static extern IntPtr GetDesktopWindow();
+
+        [DllImport("user32.dll")]
+        internal static extern IntPtr GetShellWindow();
+
+        [DllImport("user32.dll", SetLastError = true)]
+        internal static extern int GetWindowRect(IntPtr hwnd, out RECT rc);
+
+        [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+        internal static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
+
+        [DllImport("user32.DLL", CharSet = CharSet.Unicode)]
+        internal static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
+
+        public static string[] CommandLineToArgvW(string cmdLine)
+        {
+            IntPtr argv = IntPtr.Zero;
+            try
+            {
+                int numArgs = 0;
+
+                argv = _CommandLineToArgvW(cmdLine, out numArgs);
+                if (argv == IntPtr.Zero)
+                {
+                    throw new Win32Exception();
+                }
+                var result = new string[numArgs];
+
+                for (int i = 0; i < numArgs; i++)
+                {
+                    IntPtr currArg = Marshal.ReadIntPtr(argv, i * Marshal.SizeOf(typeof(IntPtr)));
+                    result[i] = Marshal.PtrToStringUni(currArg);
+                }
+
+                return result;
+            }
+            finally
+            {
+
+                IntPtr p = _LocalFree(argv);
+                // Otherwise LocalFree failed.
+                // Assert.AreEqual(IntPtr.Zero, p);
+            }
+        }
+
+    } 
+
+    public interface ISingleInstanceApp 
+    { 
+         void OnSecondAppStarted(); 
+    } 
+
+    /// <summary>
+    /// This class checks to make sure that only one instance of 
+    /// this application is running at a time.
+    /// </summary>
+    /// <remarks>
+    /// Note: this class should be used with some caution, because it does no
+    /// security checking. For example, if one instance of an app that uses this class
+    /// is running as Administrator, any other instance, even if it is not
+    /// running as Administrator, can activate it with command line arguments.
+    /// For most apps, this will not be much of an issue.
+    /// </remarks>
+    public static class SingleInstance<TApplication>  
+                where   TApplication: Application ,  ISingleInstanceApp 
+                                    
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// String delimiter used in channel names.
+        /// </summary>
+        private const string Delimiter = ":";
+
+        /// <summary>
+        /// Suffix to the channel name.
+        /// </summary>
+        private const string ChannelNameSuffix = "SingeInstanceIPCChannel";
+
+        /// <summary>
+        /// Application mutex.
+        /// </summary>
+        internal static Mutex singleInstanceMutex;
+
+        #endregion
+
+        #region Public Properties
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Checks if the instance of the application attempting to start is the first instance. 
+        /// If not, activates the first instance.
+        /// </summary>
+        /// <returns>True if this is the first instance of the application.</returns>
+        internal static bool InitializeAsFirstInstance( string uniqueName )
+        {
+            // Build unique application Id and the IPC channel name.
+            string applicationIdentifier = uniqueName + Environment.UserName;
+
+            string channelName = String.Concat(applicationIdentifier, Delimiter, ChannelNameSuffix);
+
+            // Create mutex based on unique application Id to check if this is the first instance of the application. 
+            bool firstInstance;
+            singleInstanceMutex = new Mutex(true, applicationIdentifier, out firstInstance);
+            if (firstInstance)
+            {
+                _ = CreateRemoteService(channelName);
+                return true;
+            }
+            else
+            {
+                _ = SignalFirstInstance(channelName);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Cleans up single-instance code, clearing shared resources, mutexes, etc.
+        /// </summary>
+        internal static void Cleanup()
+        {
+            singleInstanceMutex?.ReleaseMutex();
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        /// <summary>
+        /// Gets command line args - for ClickOnce deployed applications, command line args may not be passed directly, they have to be retrieved.
+        /// </summary>
+        /// <returns>List of command line arg strings.</returns>
+        private static IList<string> GetCommandLineArgs( string uniqueApplicationName )
+        {
+            string[] args = null;
+
+            try
+            {
+                // The application was not clickonce deployed, get args from standard API's
+                args = Environment.GetCommandLineArgs();
+            }
+            catch (NotSupportedException)
+            {
+              
+                // The application was clickonce deployed
+                // Clickonce deployed apps cannot receive traditional commandline arguments
+                // As a workaround commandline arguments can be written to a shared location before 
+                // the app is launched and the app can obtain its commandline arguments from the 
+                // shared location               
+                string appFolderPath = Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), uniqueApplicationName);
+
+                string cmdLinePath = Path.Combine(appFolderPath, "cmdline.txt");
+                if (File.Exists(cmdLinePath))
+                {
+                    try
+                    {
+                        using (TextReader reader = new StreamReader(cmdLinePath, Encoding.Unicode))
+                        {
+                            args = NativeMethods.CommandLineToArgvW(reader.ReadToEnd());
+                        }
+
+                        File.Delete(cmdLinePath);
+                    }
+                    catch (IOException)
+                    {
+                    }
+                }
+            }
+
+            if (args == null)
+            {
+                args = Array.Empty<string>();
+            }
+
+            return new List<string>(args);
+        }
+
+        /// <summary>
+        /// Creates a remote server pipe for communication. 
+        /// Once receives signal from client, will activate first instance.
+        /// </summary>
+        /// <param name="channelName">Application's IPC channel name.</param>
+        private static async Task CreateRemoteService(string channelName)
+        {
+            using (NamedPipeServerStream pipeServer = new NamedPipeServerStream(channelName, PipeDirection.In))
+            {
+                while(true)
+                {
+                    // Wait for connection to the pipe
+                    await pipeServer.WaitForConnectionAsync().ConfigureAwait(false);
+                    if (Application.Current != null)
+                    {
+                        // Do an asynchronous call to ActivateFirstInstance function
+                        Application.Current.Dispatcher.Invoke(ActivateFirstInstance);
+                    }
+                    // Disconnect client
+                    pipeServer.Disconnect();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a client pipe and sends a signal to server to launch first instance
+        /// </summary>
+        /// <param name="channelName">Application's IPC channel name.</param>
+        /// <param name="args">
+        /// Command line arguments for the second instance, passed to the first instance to take appropriate action.
+        /// </param>
+        private static async Task SignalFirstInstance(string channelName)
+        {
+            // Create a client pipe connected to server
+            using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", channelName, PipeDirection.Out))
+            {
+                // Connect to the available pipe
+                await pipeClient.ConnectAsync(0).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Callback for activating first instance of the application.
+        /// </summary>
+        /// <param name="arg">Callback argument.</param>
+        /// <returns>Always null.</returns>
+        private static object ActivateFirstInstanceCallback(object _)
+        {
+            ActivateFirstInstance();
+            return null;
+        }
+
+        /// <summary>
+        /// Activates the first instance of the application with arguments from a second instance.
+        /// </summary>
+        /// <param name="args">List of arguments to supply the first instance of the application.</param>
+        private static void ActivateFirstInstance()
+        {
+            // Set main window state and process command line args
+            if (Application.Current == null)
+            {
+                return;
+            }
+
+            ((TApplication)Application.Current).OnSecondAppStarted();
+        }
+
+        #endregion
+    }
+}

src/modules/launcher/PowerLauncher/Helper/WindowsInteropHelper.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows;
+using System.Windows.Forms;
+using System.Windows.Interop;
+using System.Windows.Media;
+using Point = System.Windows.Point;
+
+namespace PowerLauncher.Helper
+{
+    public static class WindowsInteropHelper
+    {
+        private const int GWL_STYLE = -16; //WPF's Message code for Title Bar's Style 
+        private const int WS_SYSMENU = 0x80000; //WPF's Message code for System Menu
+        private static IntPtr _hwnd_shell;
+        private static IntPtr _hwnd_desktop;
+
+        //Accessors for shell and desktop handlers
+        //Will set the variables once and then will return them
+        private static IntPtr HWND_SHELL
+        {
+            get
+            {
+                return _hwnd_shell != IntPtr.Zero ? _hwnd_shell : _hwnd_shell = NativeMethods.GetShellWindow();
+            }
+        }
+
+        private static IntPtr HWND_DESKTOP
+        {
+            get
+            {
+                return _hwnd_desktop != IntPtr.Zero ? _hwnd_desktop : _hwnd_desktop = NativeMethods.GetDesktopWindow();
+            }
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct INPUT
+        {
+            public INPUTTYPE type;
+            public InputUnion data;
+
+            public static int Size
+            {
+                get { return Marshal.SizeOf(typeof(INPUT)); }
+            }
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        internal struct InputUnion
+        {
+            [FieldOffset(0)]
+            internal MOUSEINPUT mi;
+            [FieldOffset(0)]
+            internal KEYBDINPUT ki;
+            [FieldOffset(0)]
+            internal HARDWAREINPUT hi;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct MOUSEINPUT
+        {
+            internal int dx;
+            internal int dy;
+            internal int mouseData;
+            internal uint dwFlags;
+            internal uint time;
+            internal UIntPtr dwExtraInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct KEYBDINPUT
+        {
+            internal short wVk;
+            internal short wScan;
+            internal uint dwFlags;
+            internal int time;
+            internal UIntPtr dwExtraInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct HARDWAREINPUT
+        {
+            internal int uMsg;
+            internal short wParamL;
+            internal short wParamH;
+        }
+
+        internal enum INPUTTYPE : uint
+        {
+            INPUTMOUSE = 0,
+            INPUTKEYBOARD = 1,
+            INPUTHARDWARE = 2,
+        }
+
+        const string WINDOW_CLASS_CONSOLE = "ConsoleWindowClass";
+        const string WINDOW_CLASS_WINTAB = "Flip3D";
+        const string WINDOW_CLASS_PROGMAN = "Progman";
+        const string WINDOW_CLASS_WORKERW = "WorkerW";
+
+        public static bool IsWindowFullscreen()
+        {
+            //get current active window
+            IntPtr hWnd = NativeMethods.GetForegroundWindow();
+
+            if (hWnd != null && !hWnd.Equals(IntPtr.Zero))
+            {
+                //if current active window is NOT desktop or shell
+                if (!(hWnd.Equals(HWND_DESKTOP) || hWnd.Equals(HWND_SHELL)))
+                {
+                    StringBuilder sb = new StringBuilder(256);
+                    _ = NativeMethods.GetClassName(hWnd, sb, sb.Capacity);
+                    string windowClass = sb.ToString();
+
+                    //for Win+Tab (Flip3D)
+                    if (windowClass == WINDOW_CLASS_WINTAB)
+                    {
+                        return false;
+                    }
+
+                    RECT appBounds;
+                    _ = NativeMethods.GetWindowRect(hWnd, out appBounds);
+
+                    //for console (ConsoleWindowClass), we have to check for negative dimensions
+                    if (windowClass == WINDOW_CLASS_CONSOLE)
+                    {
+                        return appBounds.Top < 0 && appBounds.Bottom < 0;
+                    }
+
+                    //for desktop (Progman or WorkerW, depends on the system), we have to check 
+                    if (windowClass == WINDOW_CLASS_PROGMAN || windowClass == WINDOW_CLASS_WORKERW)
+                    {
+                        IntPtr hWndDesktop = NativeMethods.FindWindowEx(hWnd, IntPtr.Zero, "SHELLDLL_DefView", null);
+                        hWndDesktop = NativeMethods.FindWindowEx(hWndDesktop, IntPtr.Zero, "SysListView32", "FolderView");
+                        if (hWndDesktop != null && !hWndDesktop.Equals(IntPtr.Zero))
+                        {
+                            return false;
+                        }
+                    }
+
+                    Rectangle screenBounds = Screen.FromHandle(hWnd).Bounds;
+                    if ((appBounds.Bottom - appBounds.Top) == screenBounds.Height && (appBounds.Right - appBounds.Left) == screenBounds.Width)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///     disable windows toolbar's control box
+        ///     this will also disable system menu with Alt+Space hotkey
+        /// </summary>
+        public static void DisableControlBox(Window win)
+        {
+            var hwnd = new WindowInteropHelper(win).Handle;
+            _ = NativeMethods.SetWindowLong(hwnd, GWL_STYLE, NativeMethods.GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
+        }
+
+        /// <summary>
+        /// Transforms pixels to Device Independent Pixels used by WPF
+        /// </summary>
+        /// <param name="visual">current window, required to get presentation source</param>
+        /// <param name="unitX">horizontal position in pixels</param>
+        /// <param name="unitY">vertical position in pixels</param>
+        /// <returns>point containing device independent pixels</returns>
+        public static Point TransformPixelsToDIP(Visual visual, double unitX, double unitY)
+        {
+            Matrix matrix;
+            var source = PresentationSource.FromVisual(visual);
+            if (source != null)
+            {
+                matrix = source.CompositionTarget.TransformFromDevice;
+            }
+            else
+            {
+                using (var src = new HwndSource(new HwndSourceParameters()))
+                {
+                    matrix = src.CompositionTarget.TransformFromDevice;
+                }
+            }
+            return new Point((int)(matrix.M11 * unitX), (int)(matrix.M22 * unitY));
+        }
+
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct RECT
+        {
+            public int Left;
+            public int Top;
+            public int Right;
+            public int Bottom;
+        }
+    }
+}