private void RemovePlugin(PluginInfo plugin)
        {
            PluginsManifest.Instance.BeginRemoval(plugin);

            Repaint();

            PluginData data = PluginsManifest.Instance.GetPluginData(plugin);

            if (data == null)
            {
                return;
            }

            bool finishOnRecompile = false;

            foreach (string file in data.copiedFiles)
            {
                if (AssetDatabase.IsValidFolder(file))
                {
                    continue;
                }
                AssetDatabase.DeleteAsset(file);
                if (!finishOnRecompile && file.EndsWith(".cs"))
                {
                    Compile.OnFinishedCompile += FinishUninstalling;
                    finishOnRecompile          = true;
                }
            }

            data.installed = false;
            data.version   = 0;
            data.copiedFiles.Clear();

            EditorUtility.SetDirty(PluginsManifest.Instance);

            DefineSymbols.Disable(plugin.GetSymbols());

            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);

            Util.DeleteEmptyFolders();

            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);

            plugin.OnRemoved();

            Repaint();

            if (!finishOnRecompile)
            {
                FinishUninstalling(true);
            }
        }
        private void ResolveDependency(PluginDependencyType type, string id)
        {
            switch (type)
            {
            case PluginDependencyType.Plugin:
                Install(AssetDatabase.LoadAssetAtPath <PluginInfo>(id));
                break;

            case PluginDependencyType.DefineSymbol:
                DefineSymbols.Add(id, "");
                break;

            case PluginDependencyType.Package:
                string[] package = id.Split(':');
                Util.AddDependencyToPackageManifest(package[0], package[1]);
                break;

            case PluginDependencyType.Module:
                ModuleInstaller.Install(AssetDatabase.LoadAssetAtPath <ModuleInstallInfo>(id).GenerateLink());
                break;
            }
            EditorApplication.delayCall += Refresh;
        }
        public static void ProceedInstall(bool compiled)
        {
            PluginsManifest.Instance.CurrentStage = (InstallStage)((int)PluginsManifest.Instance.CurrentStage + 1);
            switch (PluginsManifest.Instance.CurrentStage)
            {
            case InstallStage.InstallingUnityPackages:
                if (InstallUnityPackages())
                {
                    AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
                }
                else
                {
                    ProceedInstall(true);
                }
                break;

            case InstallStage.ModifyingPackageManager:
                if (InstallToPackageManager())
                {
                    Compile.OnFinishedCompile += ProceedInstall;
                }
                else
                {
                    ProceedInstall(true);
                }
                break;

            case InstallStage.AddingDefines:
                if (DefineSymbols.Add(PluginsManifest.Instance.CurrentPlugin.GetSymbols()))
                {
                    Compile.OnFinishedCompile += ProceedInstall;
                }
                else
                {
                    ProceedInstall(true);
                }
                break;

            case InstallStage.CopyingFiles:
                if (CopyFiles())
                {
                    Compile.OnFinishedCompile += ProceedInstall;
                }
                else
                {
                    ProceedInstall(true);
                }
                break;

            case InstallStage.InstallingModules:
                InstallModules();
                ProceedInstall(true);
                break;

            case InstallStage.Finished:

                if (HasToRecompileOnFinish())
                {
                    CompilationPipeline.RequestScriptCompilation();
                    Compile.OnFinishedCompile += FinishInstalling;
                }
                else
                {
                    FinishInstalling(true);
                }
                break;
            }
        }