Refactoring command args and change the signal instance implement.

Wox/App.xaml

@@ -4,9 +4,6 @@
             >
     <Application.Resources>
         <ResourceDictionary>
-            <ResourceDictionary.MergedDictionaries>
-				<!--<ResourceDictionary Source="Themes/Default.xaml"></ResourceDictionary>-->
-			</ResourceDictionary.MergedDictionaries>
         </ResourceDictionary>
     </Application.Resources>
 </Application>

Wox/App.xaml.cs

@@ -1,115 +1,49 @@
 using System;
-using System.Collections.ObjectModel;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Windows;
+using Wox.CommandArgs;
-using System.Windows.Forms;
-using System.Windows.Threading;
-using Microsoft.VisualBasic.ApplicationServices;
-using Wox;
-using Wox.Commands;
 using Wox.Helper;
 using Wox.Helper.ErrorReporting;
 using Application = System.Windows.Application;
 using MessageBox = System.Windows.MessageBox;
-using MessageBoxOptions = System.Windows.Forms.MessageBoxOptions;
 using StartupEventArgs = System.Windows.StartupEventArgs;
-using UnhandledExceptionEventArgs = System.UnhandledExceptionEventArgs;
 
-namespace Wox {
+namespace Wox
-	public static class EntryPoint {
+{
+    public partial class App : Application, ISingleInstanceApp
+    {
+        private const string Unique = "Wox_Unique_Application_Mutex";
+        public static MainWindow Window { get; private set; }
+
         [STAThread]
-		[System.Diagnostics.DebuggerStepThrough]
+        public static void Main()
-		public static void Main(string[] args) {
+        {
+            if (SingleInstance<App>.InitializeAsFirstInstance(Unique))
+            {
+                var application = new App();
+                application.InitializeComponent();
+                application.Run();
+                SingleInstance<App>.Cleanup();
+            }
+        }
+
+        protected override void OnStartup(StartupEventArgs e)
+        {
+            base.OnStartup(e);
+            DispatcherUnhandledException += ErrorReporting.DispatcherUnhandledException;
             AppDomain.CurrentDomain.UnhandledException += ErrorReporting.UnhandledExceptionHandle;
             System.Windows.Forms.Application.ThreadException += ErrorReporting.ThreadException;
 
-			// don't combine Main and Entry since Microsoft.VisualBasic may be unable to load
+            Window = new MainWindow();
-			// seperating them into two methods can make error reporting have the chance to catch exception
+            CommandArgsFactory.Execute(e.Args.ToList());
-			Entry(args);
         }
 
-		[System.Diagnostics.DebuggerStepThrough]
+        public bool OnActivate(IList<string> args)
-		private static void Entry(string[] args) {
+        {
-			SingleInstanceManager manager = new SingleInstanceManager();
+            CommandArgsFactory.Execute(args);
-			manager.Run(args);
-		}
-	}
-
-	// Using VB bits to detect single instances and process accordingly:
-	//  * OnStartup is fired when the first instance loads
-	//  * OnStartupNextInstance is fired when the application is re-run again
-	//    NOTE: it is redirected to this instance thanks to IsSingleInstance
-	[System.Diagnostics.DebuggerStepThrough]
-	public class SingleInstanceManager : WindowsFormsApplicationBase {
-		App app;
-
-		public SingleInstanceManager() {
-			this.IsSingleInstance = true;
-		}
-
-		protected override bool OnStartup(Microsoft.VisualBasic.ApplicationServices.StartupEventArgs e) {
-			// First time app is launched
-			app = new App();
-			//app.InitializeComponent();
-			app.Run();
             return true;
         }
-
-		protected override void OnStartupNextInstance(StartupNextInstanceEventArgs eventArgs) {
-			// Subsequent launches
-			base.OnStartupNextInstance(eventArgs);
-			app.Activate(eventArgs.CommandLine.ToArray());
-		}
-	}
-
-	public partial class App : Application {
-
-		private static MainWindow window;
-
-		public static MainWindow Window {
-			get {
-				return window;
-			}
-		}
-
-		protected override void OnStartup(StartupEventArgs e) {
-			this.DispatcherUnhandledException += ErrorReporting.DispatcherUnhandledException;
-
-			base.OnStartup(e);
-
-			//for install plugin command when wox didn't start up
-			//we shouldn't init MainWindow, just intall plugin and exit.
-			if (e.Args.Length > 0 && e.Args[0].ToLower() == "installplugin") {
-				var path = e.Args[1];
-				if (!File.Exists(path)) {
-					MessageBox.Show("Plugin " + path + " didn't exist");
-					return;
-				}
-				PluginInstaller.Install(path);
-				Environment.Exit(0);
-			}
-
-			if (e.Args.Length > 0 && e.Args[0].ToLower() == "plugindebugger") {
-				var path = e.Args[1];
-				PluginLoader.Plugins.ActivatePluginDebugger(path);
-			}
-
-			window = new MainWindow();
-			if (e.Args.Length == 0 || e.Args[0].ToLower() != "hidestart") {
-				window.ShowApp();
-			}
-
-			window.ParseArgs(e.Args);
-		}
-
-		public void Activate(string[] args) {
-			if (args.Length == 0 || args[0].ToLower() != "hidestart") {
-				window.ShowApp();
-			}
-			window.ParseArgs(args);
-		}
     }
 }

Wox/CommandArgs/CommandArgsFactory.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Windows.Input;
+
+namespace Wox.CommandArgs
+{
+    internal static class CommandArgsFactory
+    {
+        private static List<ICommandArg> commandArgs;
+
+        static CommandArgsFactory()
+        {
+            var type = typeof(ICommandArg);
+            commandArgs = Assembly.GetExecutingAssembly()
+                    .GetTypes()
+                    .Where(p => type.IsAssignableFrom(p) && !p.IsInterface)
+                    .Select(t => Activator.CreateInstance(t) as ICommandArg).ToList();
+        }
+
+        public static void Execute(IList<string> args)
+        {
+            if (args.Count > 0)
+            {
+                string command = args[0];
+                ICommandArg cmd = commandArgs.FirstOrDefault(o => o.Command.ToLower() == command);
+                if (cmd != null)
+                {
+                    args.RemoveAt(0); //remove command itself
+                    cmd.Execute(args);
+                }
+            }
+            else
+            {
+                App.Window.ShowApp();
+            }
+        }
+    }
+}

Wox/CommandArgs/HideStartCommandArg.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Wox.CommandArgs
+{
+    public class HideStartCommandArg : ICommandArg
+    {
+        public string Command
+        {
+            get { return "hidestart"; }
+        }
+
+        public void Execute(IList<string> args)
+        {
+            //App.Window.ShowApp();
+            //App.Window.HideApp();
+        }
+    }
+}

Wox/CommandArgs/ICommandArg.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Wox.CommandArgs
+{
+    interface ICommandArg
+    {
+        string Command { get; }
+        void Execute(IList<string> args);
+    }
+}

Wox/CommandArgs/InstallPluginCommandArg.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using Wox.Helper;
+
+namespace Wox.CommandArgs
+{
+    public class InstallPluginCommandArg : ICommandArg
+    {
+        public string Command
+        {
+            get { return "installplugin"; }
+        }
+
+        public void Execute(IList<string> args)
+        {
+            if (args.Count > 0)
+            {
+                var path = args[0];
+                if (!File.Exists(path))
+                {
+                    MessageBox.Show("Plugin " + path + " didn't exist");
+                    return;
+                }
+                PluginInstaller.Install(path);
+            }
+        }
+    }
+}

Wox/CommandArgs/PluginDebuggerCommandArg.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Input;
+
+namespace Wox.CommandArgs
+{
+    public class PluginDebuggerCommandArg : ICommandArg
+    {
+        public string Command
+        {
+            get { return "plugindebugger"; }
+        }
+
+        public void Execute(IList<string> args)
+        {
+            if (args.Count > 0)
+            {
+                var pluginFolderPath = args[0];
+                PluginLoader.Plugins.ActivatePluginDebugger(pluginFolderPath);
+            }
+        }
+    }
+}

Wox/CommandArgs/QueryCommandArg.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Wox.CommandArgs
+{
+    public class QueryCommandArg : ICommandArg
+    {
+        public string Command
+        {
+            get { return "query"; }
+        }
+
+        public void Execute(IList<string> args)
+        {
+            if (args.Count > 0)
+            {
+                string query = args[0];
+                App.Window.ChangeQuery(query);
+            }
+            App.Window.ShowApp();
+        }
+    }
+}

Wox/CommandArgs/ReloadPluginCommandArg.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Wox.PluginLoader;
+
+namespace Wox.CommandArgs
+{
+    public class ReloadPluginCommandArg : ICommandArg
+    {
+        public string Command
+        {
+            get { return "reloadplugin"; }
+        }
+
+        public void Execute(IList<string> args)
+        {
+            Plugins.Init();
+        }
+    }
+}

Wox/Helper/SingleInstance.cs

@@ -0,0 +1,487 @@
+//-----------------------------------------------------------------------
+// <copyright file="SingleInstance.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+// <summary>
+//     This class checks to make sure that only one instance of 
+//     this application is running at a time.
+// </summary>
+//-----------------------------------------------------------------------
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Channels;
+using System.Runtime.Remoting.Channels.Ipc;
+using System.Runtime.Serialization.Formatters;
+using System.Security;
+using System.Threading;
+using System.Windows;
+using System.Windows.Threading;
+
+//http://blogs.microsoft.co.il/arik/2010/05/28/wpf-single-instance-application/
+namespace Wox.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)]
+        private static extern IntPtr _LocalFree(IntPtr hMem);
+
+
+        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 
+    { 
+         bool OnActivate(IList<string> args); 
+    } 
+
+    /// <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>
+        /// Remote service name.
+        /// </summary>
+        private const string RemoteServiceName = "SingleInstanceApplicationService";
+
+        /// <summary>
+        /// IPC protocol used (string).
+        /// </summary>
+        private const string IpcProtocol = "ipc://";
+
+        /// <summary>
+        /// Application mutex.
+        /// </summary>
+        private static Mutex singleInstanceMutex;
+
+        /// <summary>
+        /// IPC channel for communications.
+        /// </summary>
+        private static IpcServerChannel channel;
+
+        /// <summary>
+        /// List of command line arguments for the application.
+        /// </summary>
+        private static IList<string> commandLineArgs;
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets list of command line arguments for the application.
+        /// </summary>
+        public static IList<string> CommandLineArgs
+        {
+            get { return commandLineArgs; }
+        }
+
+        #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>
+        public static bool InitializeAsFirstInstance( string uniqueName )
+        {
+            commandLineArgs = GetCommandLineArgs(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);
+            }
+            else
+            {
+                SignalFirstInstance(channelName, commandLineArgs);
+            }
+
+            return firstInstance;
+        }
+
+        /// <summary>
+        /// Cleans up single-instance code, clearing shared resources, mutexes, etc.
+        /// </summary>
+        public static void Cleanup()
+        {
+            if (singleInstanceMutex != null)
+            {
+                singleInstanceMutex.Close();
+                singleInstanceMutex = null;
+            }
+
+            if (channel != null)
+            {
+                ChannelServices.UnregisterChannel(channel);
+                channel = null;
+            }
+        }
+
+        #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;
+            if (AppDomain.CurrentDomain.ActivationContext == null)
+            {
+                // The application was not clickonce deployed, get args from standard API's
+                args = Environment.GetCommandLineArgs();
+            }
+            else
+            {
+                // The application was clickonce deployed
+                // Clickonce deployed apps cannot recieve 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, System.Text.Encoding.Unicode))
+                        {
+                            args = NativeMethods.CommandLineToArgvW(reader.ReadToEnd());
+                        }
+
+                        File.Delete(cmdLinePath);
+                    }
+                    catch (IOException)
+                    {
+                    }
+                }
+            }
+
+            if (args == null)
+            {
+                args = new string[] { };
+            }
+
+            return new List<string>(args);
+        }
+
+        /// <summary>
+        /// Creates a remote service for communication.
+        /// </summary>
+        /// <param name="channelName">Application's IPC channel name.</param>
+        private static void CreateRemoteService(string channelName)
+        {
+            BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
+            serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
+            IDictionary props = new Dictionary<string, string>();
+
+            props["name"] = channelName;
+            props["portName"] = channelName;
+            props["exclusiveAddressUse"] = "false";
+
+            // Create the IPC Server channel with the channel properties
+            channel = new IpcServerChannel(props, serverProvider);
+
+            // Register the channel with the channel services
+            ChannelServices.RegisterChannel(channel, true);
+
+            // Expose the remote service with the REMOTE_SERVICE_NAME
+            IPCRemoteService remoteService = new IPCRemoteService();
+            RemotingServices.Marshal(remoteService, RemoteServiceName);
+        }
+
+        /// <summary>
+        /// Creates a client channel and obtains a reference to the remoting service exposed by the server - 
+        /// in this case, the remoting service exposed by the first instance. Calls a function of the remoting service 
+        /// class to pass on command line arguments from the second instance to the first and cause it to activate itself.
+        /// </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 void SignalFirstInstance(string channelName, IList<string> args)
+        {
+            IpcClientChannel secondInstanceChannel = new IpcClientChannel();
+            ChannelServices.RegisterChannel(secondInstanceChannel, true);
+
+            string remotingServiceUrl = IpcProtocol + channelName + "/" + RemoteServiceName;
+
+            // Obtain a reference to the remoting service exposed by the server i.e the first instance of the application
+            IPCRemoteService firstInstanceRemoteServiceReference = (IPCRemoteService)RemotingServices.Connect(typeof(IPCRemoteService), remotingServiceUrl);
+
+            // Check that the remote service exists, in some cases the first instance may not yet have created one, in which case
+            // the second instance should just exit
+            if (firstInstanceRemoteServiceReference != null)
+            {
+                // Invoke a method of the remote service exposed by the first instance passing on the command line
+                // arguments and causing the first instance to activate itself
+                firstInstanceRemoteServiceReference.InvokeFirstInstance(args);
+            }
+        }
+
+        /// <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 arg)
+        {
+            // Get command line args to be passed to first instance
+            IList<string> args = arg as IList<string>;
+            ActivateFirstInstance(args);
+            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(IList<string> args)
+        {
+            // Set main window state and process command line args
+            if (Application.Current == null)
+            {
+                return;
+            }
+            //remove execute path itself
+            args.RemoveAt(0);
+            ((TApplication)Application.Current).OnActivate(args);
+        }
+
+        #endregion
+
+        #region Private Classes
+
+        /// <summary>
+        /// Remoting service class which is exposed by the server i.e the first instance and called by the second instance
+        /// to pass on the command line arguments to the first instance and cause it to activate itself.
+        /// </summary>
+        private class IPCRemoteService : MarshalByRefObject
+        {
+            /// <summary>
+            /// Activates the first instance of the application.
+            /// </summary>
+            /// <param name="args">List of arguments to pass to the first instance.</param>
+            public void InvokeFirstInstance(IList<string> args)
+            {
+                if (Application.Current != null)
+                {
+                    // Do an asynchronous call to ActivateFirstInstance function
+                    Application.Current.Dispatcher.BeginInvoke(
+                        DispatcherPriority.Normal, new DispatcherOperationCallback(SingleInstance<TApplication>.ActivateFirstInstanceCallback), args);
+                }
+            }
+
+            /// <summary>
+            /// Remoting Object's ease expires after every 5 minutes by default. We need to override the InitializeLifetimeService class
+            /// to ensure that lease never expires.
+            /// </summary>
+            /// <returns>Always null.</returns>
+            public override object InitializeLifetimeService()
+            {
+                return null;
+            }
+        }
+
+        #endregion
+    }
+}

Wox/MainWindow.xaml.cs

@@ -392,42 +392,6 @@ namespace Wox
             if (selectAll) tbQuery.SelectAll();
         }
 
-        public void ParseArgs(string[] args)
-        {
-            if (args != null && args.Length > 0)
-            {
-                switch (args[0].ToLower())
-                {
-                    case "reloadplugin":
-                        Plugins.Init();
-                        break;
-
-                    case "query":
-                        if (args.Length > 1)
-                        {
-                            string query = args[1];
-                            tbQuery.Text = query;
-                            tbQuery.SelectAll();
-                        }
-                        break;
-
-                    case "hidestart":
-                        HideApp();
-                        break;
-
-                    case "installplugin":
-                        var path = args[1];
-                        if (!File.Exists(path))
-                        {
-                            MessageBox.Show("Plugin " + path + " didn't exist");
-                            return;
-                        }
-                        PluginInstaller.Install(path);
-                        break;
-                }
-            }
-        }
-
         private void MainWindow_OnDeactivated(object sender, EventArgs e)
         {
             if (UserSettingStorage.Instance.HideWhenDeactive)

Wox/SettingWindow.xaml.cs

@@ -10,10 +10,6 @@ using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using IWshRuntimeLibrary;
-using Microsoft.VisualBasic.ApplicationServices;
-using Wox.Converters;
-using Wox.Infrastructure;
-using Wox.Infrastructure.Storage;
 using Wox.Infrastructure.Storage.UserSettings;
 using Wox.Plugin;
 using Wox.Helper;
@@ -23,7 +19,6 @@ using Application = System.Windows.Forms.Application;
 using File = System.IO.File;
 using MessageBox = System.Windows.MessageBox;
 using System.Windows.Data;
-using Label = System.Windows.Forms.Label;
 
 namespace Wox
 {

Wox/Wox.csproj

@@ -56,7 +56,7 @@
     <ApplicationIcon>app.ico</ApplicationIcon>
   </PropertyGroup>
   <PropertyGroup>
-    <StartupObject>Wox.EntryPoint</StartupObject>
+    <StartupObject>Wox.App</StartupObject>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Accessibility" />
@@ -68,7 +68,6 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\log4net.2.0.3\lib\net35-full\log4net.dll</HintPath>
     </Reference>
-    <Reference Include="Microsoft.VisualBasic" />
     <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\Newtonsoft.Json.6.0.5\lib\net35\Newtonsoft.Json.dll</HintPath>
@@ -87,6 +86,7 @@
     <Reference Include="System.Deployment" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Printing" />
+    <Reference Include="System.Runtime.Remoting" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Core" />
@@ -103,13 +103,20 @@
     <Reference Include="WPFToolkit, Version=3.5.40128.1, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
   </ItemGroup>
   <ItemGroup>
-    <ApplicationDefinition Include="App.xaml">
+    <Page Include="App.xaml">
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
-    </ApplicationDefinition>
+    </Page>
     <Compile Include="ActionKeyword.xaml.cs">
       <DependentUpon>ActionKeyword.xaml</DependentUpon>
     </Compile>
+    <Compile Include="CommandArgs\CommandArgsFactory.cs" />
+    <Compile Include="CommandArgs\HideStartCommandArg.cs" />
+    <Compile Include="CommandArgs\ICommandArg.cs" />
+    <Compile Include="CommandArgs\InstallPluginCommandArg.cs" />
+    <Compile Include="CommandArgs\PluginDebuggerCommandArg.cs" />
+    <Compile Include="CommandArgs\QueryCommandArg.cs" />
+    <Compile Include="CommandArgs\ReloadPluginCommandArg.cs" />
     <Compile Include="Commands\BaseCommand.cs" />
     <Compile Include="Commands\CommandFactory.cs" />
     <Compile Include="Commands\PluginCommand.cs" />
@@ -125,6 +132,7 @@
     <Compile Include="Helper\Forker.cs" />
     <Compile Include="Helper\HttpProxy.cs" />
     <Compile Include="Helper\ImageLoader.cs" />
+    <Compile Include="Helper\SingleInstance.cs" />
     <Compile Include="Helper\SyntaxSugars.cs" />
     <Compile Include="Helper\WallpaperPathRetrieval.cs" />
     <Compile Include="Helper\WindowIntelopHelper.cs" />