Rename the project.

Wox/Helper/CommonStorage.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Text;
+using System.Threading;
+using Newtonsoft.Json;
+using Wox.Models;
+
+namespace Wox.Helper
+{
+    [Serializable]
+    public class CommonStorage
+    {
+        private static string configPath = Directory.GetCurrentDirectory() + "\\data.json";
+        private static object locker = new object();
+        private static CommonStorage storage;
+
+        public UserSetting UserSetting { get; set; }
+        public UserSelectedRecords UserSelectedRecords { get; set; }
+
+        private CommonStorage()
+        {
+            //default setting
+            UserSetting = new UserSetting
+            {
+                Theme = "Default",
+                ReplaceWinR = true,
+                WebSearches = new List<WebSearch>()
+            };
+
+            UserSelectedRecords = new UserSelectedRecords();
+        }
+
+        public void Save()
+        {
+            lock (locker)
+            {
+                //json is a good choise, readable and flexiable
+                string json = JsonConvert.SerializeObject(storage, Formatting.Indented);
+                File.WriteAllText(configPath, json);
+            }
+        }
+
+        private static void Load()
+        {
+            if (!File.Exists(configPath))
+            {
+                File.Create(configPath).Close();
+            }
+            string json = File.ReadAllText(configPath);
+            if (!string.IsNullOrEmpty(json))
+            {
+                try
+                {
+                    storage = JsonConvert.DeserializeObject<CommonStorage>(json);
+                }
+                catch (Exception e)
+                {
+                    //on-op, keep default storage
+                }
+            }
+        }
+
+        public static CommonStorage Instance
+        {
+            get
+            {
+                if (storage == null)
+                {
+                    lock (locker)
+                    {
+                        if (storage == null)
+                        {
+                            storage = new CommonStorage();
+                            Load();
+                        }
+                    }
+                }
+                return storage;
+            }
+        }
+    }
+}

Wox/Helper/DwmDropShadow.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Drawing.Printing;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Interop;
+
+namespace Wox.Helper
+{
+    public static class DwmDropShadow
+    {
+
+        [DllImport("dwmapi.dll", PreserveSig = true)]
+        private static extern int DwmSetWindowAttribute(IntPtr hwnd, int attr, ref int attrValue, int attrSize);
+
+        [DllImport("dwmapi.dll")]
+        private static extern int DwmExtendFrameIntoClientArea(IntPtr hWnd, ref Margins pMarInset);
+
+        /// <summary>
+        /// Drops a standard shadow to a WPF Window, even if the window isborderless. Only works with DWM (Vista and Seven).
+        /// This method is much more efficient than setting AllowsTransparency to true and using the DropShadow effect,
+        /// as AllowsTransparency involves a huge permormance issue (hardware acceleration is turned off for all the window).
+        /// </summary>
+        /// <param name="window">Window to which the shadow will be applied</param>
+        public static void DropShadowToWindow(Window window)
+        {
+            if (!DropShadow(window))
+            {
+                window.SourceInitialized += new EventHandler(window_SourceInitialized);
+            }
+        }
+
+        private static void window_SourceInitialized(object sender, EventArgs e) //fixed typo
+        {
+            Window window = (Window)sender;
+
+            DropShadow(window);
+
+            window.SourceInitialized -= new EventHandler(window_SourceInitialized);
+        }
+
+        /// <summary>
+        /// The actual method that makes API calls to drop the shadow to the window
+        /// </summary>
+        /// <param name="window">Window to which the shadow will be applied</param>
+        /// <returns>True if the method succeeded, false if not</returns>
+        private static bool DropShadow(Window window)
+        {
+            try
+            {
+                WindowInteropHelper helper = new WindowInteropHelper(window);
+                int val = 2;
+                int ret1 = DwmSetWindowAttribute(helper.Handle, 2, ref val, 2);
+
+                if (ret1 == 0)
+                {
+                    Margins m = new Margins { Bottom = 0, Left = 0, Right = 0, Top = 0 };
+                    int ret2 = DwmExtendFrameIntoClientArea(helper.Handle, ref m);
+                    return ret2 == 0;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                // Probably dwmapi.dll not found (incompatible OS)
+                return false;
+            }
+        }
+
+    }
+}

Wox/Helper/IniParser.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections;
+using System.IO;
+
+namespace Wox.Helper
+{
+    public class IniParser
+    {
+        private Hashtable keyPairs = new Hashtable();
+        private String iniFilePath;
+
+        private struct SectionPair
+        {
+            public String Section;
+            public String Key;
+        }
+
+        /// <summary>
+        /// Opens the INI file at the given path and enumerates the values in the IniParser.
+        /// </summary>
+        /// <param name="iniPath">Full path to INI file.</param>
+        public IniParser(String iniPath)
+        {
+            TextReader iniFile = null;
+            String strLine = null;
+            String currentRoot = null;
+            String[] keyPair = null;
+
+            iniFilePath = iniPath;
+
+            if (File.Exists(iniPath))
+            {
+                try
+                {
+                    iniFile = new StreamReader(iniPath);
+
+                    strLine = iniFile.ReadLine();
+
+                    while (strLine != null)
+                    {
+                        strLine = strLine.Trim();
+
+                        if (strLine != "")
+                        {
+                            if (strLine.StartsWith("[") && strLine.EndsWith("]"))
+                            {
+                                currentRoot = strLine.Substring(1, strLine.Length - 2).ToUpper();
+                            }
+                            else
+                            {
+                                keyPair = strLine.Split(new char[] { '=' }, 2);
+
+                                SectionPair sectionPair;
+                                String value = null;
+
+                                if (currentRoot == null)
+                                    currentRoot = "ROOT";
+
+                                sectionPair.Section = currentRoot;
+                                sectionPair.Key = keyPair[0].ToUpper().Trim();
+
+                                if (keyPair.Length > 1)
+                                    value = keyPair[1];
+
+                                keyPairs.Add(sectionPair, value.Trim());
+                            }
+                        }
+
+                        strLine = iniFile.ReadLine();
+                    }
+
+                }
+                catch (Exception ex)
+                {
+                    throw ex;
+                }
+                finally
+                {
+                    if (iniFile != null)
+                        iniFile.Close();
+                }
+            }
+            else
+                throw new FileNotFoundException("Unable to locate " + iniPath);
+        }
+
+        /// <summary>
+        /// Returns the value for the given section, key pair.
+        /// </summary>
+        /// <param name="sectionName">Section name.</param>
+        /// <param name="settingName">Key name.</param>
+        public String GetSetting(String sectionName, String settingName)
+        {
+            SectionPair sectionPair;
+            sectionPair.Section = sectionName.ToUpper().Trim();
+            sectionPair.Key = settingName.ToUpper().Trim();
+
+            return (String)keyPairs[sectionPair];
+        }
+
+        /// <summary>
+        /// Enumerates all lines for given section.
+        /// </summary>
+        /// <param name="sectionName">Section to enum.</param>
+        public String[] EnumSection(String sectionName)
+        {
+            ArrayList tmpArray = new ArrayList();
+
+            foreach (SectionPair pair in keyPairs.Keys)
+            {
+                if (pair.Section == sectionName.ToUpper())
+                    tmpArray.Add(pair.Key);
+            }
+
+            return (String[])tmpArray.ToArray(typeof(String));
+        }
+
+        /// <summary>
+        /// Adds or replaces a setting to the table to be saved.
+        /// </summary>
+        /// <param name="sectionName">Section to add under.</param>
+        /// <param name="settingName">Key name to add.</param>
+        /// <param name="settingValue">Value of key.</param>
+        public void AddSetting(String sectionName, String settingName, String settingValue)
+        {
+            SectionPair sectionPair;
+            sectionPair.Section = sectionName.ToUpper();
+            sectionPair.Key = settingName.ToUpper();
+
+            if (keyPairs.ContainsKey(sectionPair))
+                keyPairs.Remove(sectionPair);
+
+            keyPairs.Add(sectionPair, settingValue);
+        }
+
+        /// <summary>
+        /// Adds or replaces a setting to the table to be saved with a null value.
+        /// </summary>
+        /// <param name="sectionName">Section to add under.</param>
+        /// <param name="settingName">Key name to add.</param>
+        public void AddSetting(String sectionName, String settingName)
+        {
+            AddSetting(sectionName, settingName, null);
+        }
+
+        /// <summary>
+        /// Remove a setting.
+        /// </summary>
+        /// <param name="sectionName">Section to add under.</param>
+        /// <param name="settingName">Key name to add.</param>
+        public void DeleteSetting(String sectionName, String settingName)
+        {
+            SectionPair sectionPair;
+            sectionPair.Section = sectionName.ToUpper();
+            sectionPair.Key = settingName.ToUpper();
+
+            if (keyPairs.ContainsKey(sectionPair))
+                keyPairs.Remove(sectionPair);
+        }
+
+        /// <summary>
+        /// Save settings to new file.
+        /// </summary>
+        /// <param name="newFilePath">New file path.</param>
+        public void SaveSettings(String newFilePath)
+        {
+            ArrayList sections = new ArrayList();
+            String tmpValue = "";
+            String strToSave = "";
+
+            foreach (SectionPair sectionPair in keyPairs.Keys)
+            {
+                if (!sections.Contains(sectionPair.Section))
+                    sections.Add(sectionPair.Section);
+            }
+
+            foreach (String section in sections)
+            {
+                strToSave += ("[" + section + "]\r\n");
+
+                foreach (SectionPair sectionPair in keyPairs.Keys)
+                {
+                    if (sectionPair.Section == section)
+                    {
+                        tmpValue = (String)keyPairs[sectionPair];
+
+                        if (tmpValue != null)
+                            tmpValue = "=" + tmpValue;
+
+                        strToSave += (sectionPair.Key + tmpValue + "\r\n");
+                    }
+                }
+
+                strToSave += "\r\n";
+            }
+
+            try
+            {
+                TextWriter tw = new StreamWriter(newFilePath);
+                tw.Write(strToSave);
+                tw.Close();
+            }
+            catch (Exception ex)
+            {
+                throw ex;
+            }
+        }
+
+        /// <summary>
+        /// Save settings back to ini file.
+        /// </summary>
+        public void SaveSettings()
+        {
+            SaveSettings(iniFilePath);
+        }
+    }
+}

Wox/Helper/KeyboardHook.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Wox.Helper
+{
+    public sealed class KeyboardHook : IDisposable
+    {
+        // Registers a hot key with Windows.
+        [DllImport("user32.dll")]
+        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+        // Unregisters the hot key with Windows.
+        [DllImport("user32.dll")]
+        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+        /// <summary>
+        /// Represents the window that is used internally to get the messages.
+        /// </summary>
+        private class Window : NativeWindow, IDisposable
+        {
+            private static int wmHotkey = 0x0312;
+
+            public Window()
+            {
+                // create the handle for the window.
+                CreateHandle(new CreateParams());
+            }
+
+            /// <summary>
+            /// Overridden to get the notifications.
+            /// </summary>
+            /// <param name="m"></param>
+            protected override void WndProc(ref Message m)
+            {
+                base.WndProc(ref m);
+
+                // check if we got a hot key pressed.
+                if (m.Msg == wmHotkey)
+                {
+                    // get the keys.
+                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
+                    XModifierKeys xModifier = (XModifierKeys)((int)m.LParam & 0xFFFF);
+
+                    // invoke the event to notify the parent.
+                    if (KeyPressed != null)
+                        KeyPressed(this, new KeyPressedEventArgs(xModifier, key));
+                }
+            }
+
+            public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+            #region IDisposable Members
+
+            public void Dispose()
+            {
+                DestroyHandle();
+            }
+
+            #endregion
+        }
+
+        private Window window = new Window();
+        private int currentId;
+
+        public KeyboardHook()
+        {
+            // register the event of the inner native window.
+            window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
+            {
+                if (KeyPressed != null)
+                    KeyPressed(this, args);
+            };
+        }
+
+        /// <summary>
+        /// Registers a hot key in the system.
+        /// </summary>
+        /// <param name="xModifier">The modifiers that are associated with the hot key.</param>
+        /// <param name="key">The key itself that is associated with the hot key.</param>
+        public void RegisterHotKey(XModifierKeys xModifier, Keys key)
+        {
+            // increment the counter.
+            currentId = currentId + 1;
+
+            // register the hot key.
+            if (!RegisterHotKey(window.Handle, currentId, (uint)xModifier, (uint)key))
+            {
+                Log.Error("Couldn’t register the hot key.");
+                MessageBox.Show("Couldn’t register the hot key.");
+#if (DEBUG)
+                {
+                    throw new InvalidOperationException("Couldn’t register the hot key.");
+                }
+#endif
+            }
+        }
+
+        /// <summary>
+        /// A hot key has been pressed.
+        /// </summary>
+        public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            // unregister all the registered hot keys.
+            for (int i = currentId; i > 0; i--)
+            {
+                UnregisterHotKey(window.Handle, i);
+            }
+
+            // dispose the inner native window.
+            window.Dispose();
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Event Args for the event that is fired after the hot key has been pressed.
+    /// </summary>
+    public class KeyPressedEventArgs : EventArgs
+    {
+        private XModifierKeys xModifier;
+        private Keys key;
+
+        internal KeyPressedEventArgs(XModifierKeys xModifier, Keys key)
+        {
+            this.xModifier = xModifier;
+            this.key = key;
+        }
+
+        public XModifierKeys XModifier
+        {
+            get { return xModifier; }
+        }
+
+        public Keys Key
+        {
+            get { return key; }
+        }
+    }
+
+    /// <summary>
+    /// The enumeration of possible modifiers.
+    /// </summary>
+    public enum XModifierKeys : uint
+    {
+        Alt = 1,
+        Control = 2,
+        Shift = 4,
+        Win = 8
+    }
+}

Wox/Helper/KeyboardListener.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Wox.Helper
+{
+    public enum KeyEvent : int
+    {
+        /// <summary>
+        /// Key down
+        /// </summary>
+        WM_KEYDOWN = 256,
+
+        /// <summary>
+        /// Key up
+        /// </summary>
+        WM_KEYUP = 257,
+
+        /// <summary>
+        /// System key up
+        /// </summary>
+        WM_SYSKEYUP = 261,
+
+        /// <summary>
+        /// System key down
+        /// </summary>
+        WM_SYSKEYDOWN = 260
+    }
+
+    public class SpecialKeyState
+    {
+        public bool CtrlPressed { get; set; }
+        public bool ShiftPressed { get; set; }
+        public bool AltPressed { get; set; }
+        public bool WinPressed { get; set; }
+    }
+
+    /// <summary>
+    /// Listens keyboard globally.
+    /// 
+    /// <remarks>Uses WH_KEYBOARD_LL.</remarks>
+    /// </summary>
+    public class KeyboardListener : IDisposable
+    {
+        private InterceptKeys.LowLevelKeyboardProc hookedLowLevelKeyboardProc;
+        private IntPtr hookId = IntPtr.Zero;
+        public delegate bool KeyboardCallback(KeyEvent keyEvent, int vkCode, SpecialKeyState state);
+        public event KeyboardCallback hookedKeyboardCallback;
+
+        //Modifier key constants
+        private const int VK_SHIFT = 0x10;
+        private const int VK_CONTROL = 0x11;
+        private const int VK_ALT = 0x12;
+        private const int VK_WIN = 91;
+
+        public KeyboardListener()
+        {
+            // We have to store the LowLevelKeyboardProc, so that it is not garbage collected runtime
+            hookedLowLevelKeyboardProc = LowLevelKeyboardProc;
+            // Set the hook
+            hookId = InterceptKeys.SetHook(hookedLowLevelKeyboardProc);
+        }
+
+        private SpecialKeyState CheckModifiers()
+        {
+            SpecialKeyState state = new SpecialKeyState();
+            if ((InterceptKeys.GetKeyState(VK_SHIFT) & 0x8000) != 0)
+            {
+                //SHIFT is pressed
+                state.ShiftPressed = true;
+            }
+            if ((InterceptKeys.GetKeyState(VK_CONTROL) & 0x8000) != 0)
+            {
+                //CONTROL is pressed
+                state.CtrlPressed = true;
+            }
+            if ((InterceptKeys.GetKeyState(VK_ALT) & 0x8000) != 0)
+            {
+                //ALT is pressed
+                state.AltPressed = true;
+            }
+            if ((InterceptKeys.GetKeyState(VK_WIN) & 0x8000) != 0)
+            {
+                //ALT is pressed
+                state.WinPressed = true;
+            }
+
+            return state;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)
+        {
+            bool continues = true;
+
+            if (nCode >= 0)
+            {
+                if (wParam.ToUInt32() == (int)KeyEvent.WM_KEYDOWN ||
+                    wParam.ToUInt32() == (int)KeyEvent.WM_KEYUP ||
+                    wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYDOWN ||
+                    wParam.ToUInt32() == (int)KeyEvent.WM_SYSKEYUP)
+                {
+                    if (hookedKeyboardCallback != null)
+                        continues = hookedKeyboardCallback((KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam), CheckModifiers());
+                }
+            }
+
+            if (continues)
+            {
+                return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam);
+            }
+            return (IntPtr)1;
+        }
+
+        ~KeyboardListener()
+        {
+            Dispose();
+        }
+
+        public void Dispose()
+        {
+            InterceptKeys.UnhookWindowsHookEx(hookId);
+        }
+    }
+
+    public static class InterceptKeys
+    {
+        public delegate IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam);
+
+        private static int WH_KEYBOARD_LL = 13;
+
+        public static IntPtr SetHook(LowLevelKeyboardProc proc)
+        {
+            using (Process curProcess = Process.GetCurrentProcess())
+            using (ProcessModule curModule = curProcess.MainModule)
+            {
+                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
+            }
+        }
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool UnhookWindowsHookEx(IntPtr hhk);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, UIntPtr wParam, IntPtr lParam);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr GetModuleHandle(string lpModuleName);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true, CallingConvention = CallingConvention.Winapi)]
+        public static extern short GetKeyState(int keyCode);
+
+        [DllImport("user32.dll")]
+        internal static extern uint SendInput(uint nInputs, [MarshalAs(UnmanagedType.LPArray), In] INPUT[] pInputs, int cbSize);
+
+
+        public static void SendKeyStroke(int funckey, int key)
+        {
+            INPUT[] input = new INPUT[4];
+            input[0].type = input[1].type = input[2].type = input[3].type = (int)InputType.INPUT_KEYBOARD;
+            input[0].ki.wVk = input[2].ki.wVk = (short) funckey;
+            input[1].ki.wVk = input[3].ki.wVk = (short) key;
+
+            input[2].ki.dwFlags = input[3].ki.dwFlags =(int) KEYEVENTF.KEYUP;
+
+            SendInput((uint)input.Length, input, Marshal.SizeOf(input[0]));
+        }
+    }
+
+    public enum InputType
+    {
+        INPUT_MOUSE = 0,
+        INPUT_KEYBOARD = 1,
+        INPUT_HARDWARE = 2,
+    }
+    [Flags()]
+    public enum MOUSEEVENTF
+    {
+        MOVE = 0x0001,  //mouse move   
+        LEFTDOWN = 0x0002,  //left button down   
+        LEFTUP = 0x0004,  //left button up   
+        RIGHTDOWN = 0x0008,  //right button down   
+        RIGHTUP = 0x0010,  //right button up   
+        MIDDLEDOWN = 0x0020, //middle button down   
+        MIDDLEUP = 0x0040,  //middle button up   
+        XDOWN = 0x0080,  //x button down   
+        XUP = 0x0100,  //x button down   
+        WHEEL = 0x0800,  //wheel button rolled   
+        VIRTUALDESK = 0x4000,  //map to entire virtual desktop   
+        ABSOLUTE = 0x8000,  //absolute move   
+    }
+
+    [Flags()]
+    public enum KEYEVENTF
+    {
+        EXTENDEDKEY = 0x0001,
+        KEYUP = 0x0002,
+        UNICODE = 0x0004,
+        SCANCODE = 0x0008,
+    }
+    [StructLayout(LayoutKind.Explicit)]
+    public struct INPUT
+    {
+        [FieldOffset(0)]
+        public Int32 type;//0-MOUSEINPUT;1-KEYBDINPUT;2-HARDWAREINPUT   
+        [FieldOffset(4)]
+        public KEYBDINPUT ki;
+        [FieldOffset(4)]
+        public MOUSEINPUT mi;
+        [FieldOffset(4)]
+        public HARDWAREINPUT hi;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MOUSEINPUT
+    {
+        public Int32 dx;
+        public Int32 dy;
+        public Int32 mouseData;
+        public Int32 dwFlags;
+        public Int32 time;
+        public IntPtr dwExtraInfo;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KEYBDINPUT
+    {
+        public Int16 wVk;
+        public Int16 wScan;
+        public Int32 dwFlags;
+        public Int32 time;
+        public IntPtr dwExtraInfo;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    public struct HARDWAREINPUT
+    {
+        public Int32 uMsg;
+        public Int16 wParamL;
+        public Int16 wParamH;
+    }
+}

Wox/Helper/Log.cs

@@ -0,0 +1,15 @@
+using System.Reflection;
+using log4net;
+
+namespace Wox.Helper
+{
+    public class Log
+    {
+        private static ILog fileLogger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static void Error(string msg)
+        {
+            fileLogger.Error(msg);
+        }
+    }
+}

Wox/Helper/WoxException.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Wox.Helper
+{
+    public class WoxException : Exception
+    {
+        public WoxException(string msg)
+            : base(msg)
+        {
+
+        }
+    }
+}