PowerToys/Plugins/Wox.Plugin.CMD/CMD.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;
using WindowsInput;
using WindowsInput.Native;
using Wox.Infrastructure;
using Wox.Infrastructure.Hotkey;
using Control = System.Windows.Controls.Control;

namespace Wox.Plugin.CMD
{
    public class CMD : IPlugin, ISettingProvider, IPluginI18n, IInstantSearch
    {
        private PluginInitContext context;
        private bool WinRStroked;
        private readonly KeyboardSimulator keyboardSimulator = new KeyboardSimulator(new InputSimulator());

        public List<Result> Query(Query query)
        {
            List<Result> results = new List<Result>();
            List<Result> pushedResults = new List<Result>();
            if (query.Search == ">")
            {
                return GetAllHistoryCmds();
            }

            if (query.Search.StartsWith(">") && query.Search.Length > 1)
            {
                string cmd = query.Search.Substring(1);
                var queryCmd = GetCurrentCmd(cmd);
                context.API.PushResults(query, context.CurrentPluginMetadata, new List<Result>() { queryCmd });
                pushedResults.Add(queryCmd);

                var history = GetHistoryCmds(cmd, queryCmd);
                context.API.PushResults(query, context.CurrentPluginMetadata, history);
                pushedResults.AddRange(history);


                try
                {
                    string basedir = null;
                    string dir = null;
                    string excmd = Environment.ExpandEnvironmentVariables(cmd);
                    if (Directory.Exists(excmd) && (cmd.EndsWith("/") || cmd.EndsWith(@"\")))
                    {
                        basedir = excmd;
                        dir = cmd;
                    }
                    else if (Directory.Exists(Path.GetDirectoryName(excmd)))
                    {
                        basedir = Path.GetDirectoryName(excmd);
                        var dirn = Path.GetDirectoryName(cmd);
                        dir = (dirn.EndsWith("/") || dirn.EndsWith(@"\")) ? dirn : cmd.Substring(0, dirn.Length + 1);
                    }

                    if (basedir != null)
                    {
                        List<string> autocomplete = Directory.GetFileSystemEntries(basedir).Select(o => dir + Path.GetFileName(o)).Where(o => o.StartsWith(cmd, StringComparison.OrdinalIgnoreCase) && !results.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase)) && !pushedResults.Any(p => o.Equals(p.Title, StringComparison.OrdinalIgnoreCase))).ToList();
                        autocomplete.Sort();
                        results.AddRange(autocomplete.ConvertAll(m => new Result()
                        {
                            Title = m,
                            IcoPath = "Images/cmd.png",
                            Action = (c) =>
                            {
                                ExecuteCmd(m);
                                return true;
                            },
                            ContextMenu = GetContextMenus(m)
                        }));
                    }
                }
                catch (Exception) { }

            }
            return results;
        }

        private List<Result> GetHistoryCmds(string cmd, Result result)
        {
            IEnumerable<Result> history = CMDStorage.Instance.CMDHistory.Where(o => o.Key.Contains(cmd))
                .OrderByDescending(o => o.Value)
                .Select(m =>
                {
                    if (m.Key == cmd)
                    {
                        result.SubTitle = "this command has been executed " + m.Value + " times";
                        return null;
                    }

                    var ret = new Result
                    {
                        Title = m.Key,
                        SubTitle = "this command has been executed " + m.Value + " times",
                        IcoPath = "Images/cmd.png",
                        Action = (c) =>
                        {
                            ExecuteCmd(m.Key);
                            return true;
                        },
                        ContextMenu = GetContextMenus(m.Key)
                    };
                    return ret;
                }).Where(o => o != null).Take(4);
            return history.ToList();
        }

        private Result GetCurrentCmd(string cmd)
        {
            Result result = new Result
            {
                Title = cmd,
                Score = 5000,
                SubTitle = "execute command through command shell",
                IcoPath = "Images/cmd.png",
                Action = (c) =>
                {
                    ExecuteCmd(cmd);
                    return true;
                },
                ContextMenu = GetContextMenus(cmd)
            };

            return result;
        }

        private List<Result> GetAllHistoryCmds()
        {
            IEnumerable<Result> history = CMDStorage.Instance.CMDHistory.OrderByDescending(o => o.Value)
                .Select(m => new Result
                {
                    Title = m.Key,
                    SubTitle = "this command has been executed " + m.Value + " times",
                    IcoPath = "Images/cmd.png",
                    Action = (c) =>
                    {
                        ExecuteCmd(m.Key);
                        return true;
                    },
                    ContextMenu = GetContextMenus(m.Key)
                }).Take(5);
            return history.ToList();
        }

        private List<Result> GetContextMenus(string cmd)
        {
            return new List<Result>()
                     {
                        new Result()
                        {
                            Title = "Run As Administrator",
                            Action = c =>
                            {
                                context.API.HideApp();
                                ExecuteCmd(cmd, true);
                                return true;
                            },
                            IcoPath = "Images/cmd.png"
                        }
                     };
        }

        private void ExecuteCmd(string cmd, bool runAsAdministrator = false)
        {
            if (context.API.ShellRun(cmd, runAsAdministrator))
                CMDStorage.Instance.AddCmdHistory(cmd);
        }

        public void Init(PluginInitContext context)
        {
            this.context = context;
            context.API.GlobalKeyboardEvent += API_GlobalKeyboardEvent;
        }

        bool API_GlobalKeyboardEvent(int keyevent, int vkcode, SpecialKeyState state)
        {
            if (CMDStorage.Instance.ReplaceWinR)
            {
                if (keyevent == (int)KeyEvent.WM_KEYDOWN && vkcode == (int)Keys.R && state.WinPressed)
                {
                    WinRStroked = true;
                    OnWinRPressed();
                    return false;
                }
                if (keyevent == (int)KeyEvent.WM_KEYUP && WinRStroked && vkcode == (int)Keys.LWin)
                {
                    WinRStroked = false;
                    keyboardSimulator.ModifiedKeyStroke(VirtualKeyCode.LWIN, VirtualKeyCode.CONTROL);
                    return false;
                }
            }
            return true;
        }

        private void OnWinRPressed()
        {
            context.API.ShowApp();
            context.API.ChangeQuery(">");
        }

        public Control CreateSettingPanel()
        {
            return new CMDSetting();
        }

        public string GetLanguagesFolder()
        {
            return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Languages");
        }

        public bool IsInstantSearch(string query)
        {
            if (query.StartsWith(">")) return true;
            return false;
        }
    }
}