Пример #1
0
        private void BeginInstall()
        {
            int requiredValue = (pepperBox.Checked ? 1 : 0) + (netscapeBox.Checked ? 1 : 0) + (activeXBox.Checked ? 2 : 0);

            if (Environment.Is64BitOperatingSystem)
            {
                requiredValue *= 2;
            }

            requiredValue += UNINSTALL_TICKS;
            requiredValue += INSTALL_GENERAL_TICKS;

            progressBar.Value   = 0;
            progressBar.Maximum = requiredValue;

            new Task(new Action(() => {
                IntPtr redirection = RedirectionManager.DisableRedirection();

                try {
                    Uninstaller.Uninstall(this);
                    Installer.Install(this, pepperBox.Checked, netscapeBox.Checked, activeXBox.Checked);
                    Complete();
                } catch (Exception e) {
                    Failure(e);
                } finally {
                    RedirectionManager.EnableRedirection(redirection);
                }
            })).Start();
        }
 /// <summary>
 /// Uninstalls the application based on the existing options
 /// </summary>
 private void Uninstall()
 {
     if (!Directory.Exists(InstallLocation))
     {
         ConsoleUtils.FormattedWrite("Install location does not exist");
     }
     else if (!SaveData)
     {
         Uninstaller.UninstallApp(Shortcuts, InstallLocation);
         ConsoleUtils.FormattedWrite("Application successfully uninstalled");
     }
     else if (Directory.Exists(SaveLocation) || (!Directory.Exists(SaveLocation) &&
                                                 YesChoices.Contains(ConsoleUtils.FancyGetAllowedInput(AllowedOptions, "Save Folder does not exist so installer will need to create one. Continue?"))))
     {
         Uninstaller.MoveApp(Shortcuts, InstallLocation, SaveLocation);
         ConsoleUtils.FormattedWrite("Application successfully uninstalled");
     }
     ConsoleUtils.FormattedWrite("Press any key to continue...", new FormattedWriteSettings()
     {
         NewLine = false
     });
     Console.CursorVisible = false;
     Console.ReadKey(true);
     Console.CursorVisible = true;
 }
Пример #3
0
        public override IEnumerable <JunkNode> FindJunk()
        {
            var returnList = new List <JunkNode>();

            returnList.AddRange(ScanForJunk());

            returnList.AddRange(ScanFirewallRules());

            returnList.AddRange(ScanTracing());

            returnList.AddRange(ScanClsid());

            returnList.AddRange(ScanAudioPolicyConfig());

            returnList.AddRange(ScanUserAssist());

            returnList.AddRange(ScanAppCompatFlags());

            returnList.AddRange(ScanEventLogs());

            returnList.AddRange(ScanInstallerFolders());

            if (Uninstaller.RegKeyStillExists())
            {
                var regKeyNode = new RegistryKeyJunkNode(PathTools.GetDirectory(Uninstaller.RegistryPath),
                                                         Uninstaller.RegistryKeyName, Uninstaller.DisplayName);
                regKeyNode.Confidence.Add(ConfidencePart.IsUninstallerRegistryKey);
                returnList.Add(regKeyNode);
            }

            return(returnList);
        }
Пример #4
0
        private void RevertButton_Click(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;

            var dialogResult = MessageBox.Show(
                "Do you really want to revert all changes?",
                "Are you sure?",
                MessageBoxButtons.YesNo,
                MessageBoxIcon.Question,
                MessageBoxDefaultButton.Button2);

            if (dialogResult != DialogResult.Yes)
            {
                return;
            }

            Cursor.Current = Cursors.WaitCursor;

            _hostsFileAccess.RemoveUrls();
            _spotifyUpdateDirectoryAccess.Allow();

            if (CleanupCheckBox.Checked)
            {
                var uninstaller = new Uninstaller(OutputTextBox);
                uninstaller.UninstallSpotify();
            }

            SetUiAndConfig(false);

            OutputTextBox.AppendText("\r\nAll changes successfully reverted!", Color.Green);
            OutputTextBox.AppendText(_textBoxSeparator);

            SystemSounds.Asterisk.Play();
        }
Пример #5
0
        private void BeginInstall()
        {
            InstallFlags flags = new InstallFlags();

            flags.SetConditionally(pepperBox.Checked, InstallFlags.PEPPER);
            flags.SetConditionally(netscapeBox.Checked, InstallFlags.NETSCAPE);
            flags.SetConditionally(activeXBox.Checked, InstallFlags.ACTIVEX);
            flags.SetConditionally(playerBox.Checked, InstallFlags.PLAYER);
            flags.SetConditionally(playerDesktopBox.Checked, InstallFlags.PLAYER_DESKTOP);
            flags.SetConditionally(playerStartMenuBox.Checked, InstallFlags.PLAYER_START_MENU);

            progressBar.Value   = 0;
            progressBar.Maximum = flags.GetTicks();

            new Task(new Action(() => {
                IntPtr redirection = RedirectionManager.DisableRedirection();

                try {
                    Uninstaller.Uninstall(this);
                    Installer.Install(this, flags);
                    Complete();
                } catch (Exception e) {
                    Failure(e);
                } finally {
                    RedirectionManager.EnableRedirection(redirection);
                }
            })).Start();
        }
Пример #6
0
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            string installPath = (string)Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\" + installedPathRegKeyName, "InstallPath", "") ?? "";

            state = InstallerState.Read(installPath);
            state.Update();
            if (e.Args.Length > 0 && e.Args[0] == "/uninstall")
            {
                if (MessageBox.Show("Are you sure you want to uninstall KinectToVR?", "Confirm", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    if (Uninstaller.UninstallK2EX(installPath))
                    {
                        MessageBox.Show("Uninstalled successfully!");
                        if (Directory.Exists(installPath))
                        {
                            // https://stackoverflow.com/a/1305478/
                            ProcessStartInfo Info = new ProcessStartInfo();
                            Info.Arguments      = "/C choice /C Y /N /D Y /T 3 & rmdir /S /Q \"" + installPath + "\"";
                            Info.WindowStyle    = ProcessWindowStyle.Hidden;
                            Info.CreateNoWindow = true;
                            Info.FileName       = "cmd.exe";
                            Process.Start(Info);
                        }
                    }
                }
                Current.Shutdown(0);
            }
        }
        internal DebugWindow(MainWindow reference, UninstallerListViewTools listview, Uninstaller uninstaller)
        {
            _reference   = reference;
            _listView    = listview;
            _uninstaller = uninstaller;

            InitializeComponent();

            _settings.Subscribe(TestHandler, x => x.FilterHideMicrosoft, this);
            _settings.BindControl(checkBox1, x => x.FilterHideMicrosoft, this);

            _settings.BindControl(checkBoxDebug, x => x.Debug, this);
            checkBoxDebug.Checked = Settings.Default.Debug;

            var messageboxes =
                typeof(MessageBoxes).GetMethods(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);

            foreach (var x in messageboxes)
            {
                var wr = new ComboBoxWrapper <MethodInfo>(x, y =>
                {
                    var name = y.ToString();
                    return(name.Substring(name.IndexOf(' ') + 1));
                });
                comboBoxMessages.Items.Add(wr);
            }

            checkBox2.Checked = Program.IsInstalled;
        }
Пример #8
0
        /// <summary>
        ///     Backend input
        /// </summary>
        /// <param name="inputargs">Input</param>
        ///
        public static void doCommand(string[] inputargs)
        {
            for (int repeat = 1; repeat < inputargs.Length; repeat++)
            {
                Console.WriteLine("doing {0} {1}", inputargs[0], inputargs[repeat]);
                switch (inputargs[0])
                {
                case "dl":
                    Downloader.DownloadModDirector(inputargs[repeat]);
                    break;

                //deletion
                case "rm":
                    Console.WriteLine($"Deleting {inputargs[repeat]}");
                    Uninstaller.DeleteMod(inputargs[repeat]);
                    break;

                case "disable":
                    Disabler.EnableDisableMod(inputargs[repeat]);
                    break;

                default:
                    Console.WriteLine("Invalid command!");
                    break;
                }
            }

            switch (inputargs[0])
            {
            case "wipe":
                File.Delete(Utilities.ModCache);
                Console.WriteLine("Wiped!");
                break;
            }
        }
Пример #9
0
        private void buttonSort_Click(object sender, EventArgs e)
        {
            objectListView1.PrimarySortColumn = null;
            var results = Uninstaller.SortIntelligently(Entries, entry => entry.Entry);

            objectListView1.SetObjects(results.ToList());
        }
Пример #10
0
        public void Can_Add_Section()
        {
            // delete it if it exists, before running installer
            Uninstaller.RemoveSection();

            Assert.Null(_sectionService.GetByAlias("workflow"));

            Assert.True(Installer.AddSection(ApplicationContext.Current));
        }
Пример #11
0
        private void buttonAccept_Click(object sender, EventArgs e)
        {
            var filters = SelectedJunk.OfType <DriveJunkNode>().Select(x => x.FullName).ToArray();

            if (!Uninstaller.CheckForRunningProcesses(filters, false, this))
            {
                return;
            }

            if (SelectedJunk.Any(x => !(x is DriveJunkNode)))
            {
                switch (MessageBoxes.BackupRegistryQuestion(this))
                {
                case MessageBoxes.PressedButton.Yes:
                    if (backupDirDialog.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }

                    var dir = Path.Combine(backupDirDialog.SelectedPath, GetUniqueBackupName());
                    try
                    {
                        Directory.CreateDirectory(dir);
                    }
                    catch (Exception ex)
                    {
                        PremadeDialogs.GenericError(ex);
                        goto case MessageBoxes.PressedButton.Yes;
                    }

                    try
                    {
                        FilesystemTools.CompressDirectory(dir);
                    }
                    catch
                    {
                        // Ignore, not important
                    }

                    if (!RunBackup(dir))
                    {
                        return;
                    }

                    break;

                case MessageBoxes.PressedButton.No:
                    break;

                default:
                    return;
                }
            }

            DialogResult = DialogResult.OK;
            Close();
        }
Пример #12
0
        public void Can_Add_Dashboards()
        {
            Uninstaller.RemoveSectionDashboard();
            Assert.True(Installer.AddSectionDashboard());
            Assert.True(Installer.AddContentSectionDashboard());

            // installing when dashboards exist will fail
            Assert.False(Installer.AddSectionDashboard());
            Assert.False(Installer.AddContentSectionDashboard());
        }
        public WindowsOperationHandler()
        {
            // Have to make sure the Windows Update Agent is up to date.
            WUAUpdater.Run();

            session = new UpdateSession();
            windowsUninstaller = new Uninstaller();

            updateWorker.DoWork += new DoWorkEventHandler(DownloadAndInstallUpdates);
            updateWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(DownloadAndInstallCompleted);
        }
Пример #14
0
        /// <summary>
        ///     Backend input
        /// </summary>
        /// <param name="inputargs">Input</param>
        ///
        public static void doCommand(string[] inputargs)
        {
            switch (inputargs[0])
            {
            case "wipe":
                File.Delete(Utilities.ModCache);
                Console.WriteLine("Wiped!");
                break;

            case "check":

                var ml = JsonModList.GetModLists();

                for (var i = 0; i < ml.Length; i++)
                {
                    for (var x = 0; x < ml[i].Modlist.Length; x++)
                    {
                        if (ml[i].Modlist[x].ModId == inputargs[1])
                        {
                            var link = ml[i].Modlist[x].Website;
                            var psi  = new ProcessStartInfo
                            {
                                FileName        = link,
                                UseShellExecute = true
                            };
                            Process.Start(psi);
                        }
                    }
                }

                break;

            case "dl":
                Downloader.DownloadModDirector(inputargs[1]);
                break;

            case "toggledebugging":
                ModInstallerCommon.enableDebugging = !ModInstallerCommon.enableDebugging;
                Console.WriteLine("Debugging is now " + ModInstallerCommon.enableDebugging);
                break;

            //deletion
            case "rm":
                Console.WriteLine($"Deleting {inputargs[1]}");
                Uninstaller.DeleteMod(inputargs[1]);
                break;

            default:
                Console.WriteLine("Invalid command!");
                break;
            }
        }
Пример #15
0
#pragma warning restore 1998

        public async Task Uninstall(IProgress <Tuple <int, string> > progress = null, bool dryRun = true)
        {
            // First, remove the desktop entry and "sqrl://" scheme handlers
            progress.Report(new Tuple <int, string>(0, $"Removing desktop entries and sqrl:// scheme handlers"));
            var desktopFile = Path.Combine(PathConf.ClientInstallPath, "sqrldev-sqrl.desktop");

            _shell.Term($"xdg-mime uninstall {desktopFile}", Output.Internal);
            _shell.Term($"xdg-desktop-menu uninstall sqrldev-sqrl.desktop", Output.Internal);
            _shell.Term($"update-desktop-database {SystemAndShellUtils.GetHomePath()}/.local/share/applications/", Output.Internal);

            // Run the inventory-based uninstaller
            await Uninstaller.Run(progress, dryRun);
        }
Пример #16
0
        public async Task SetupAsync()
        {
            commandDirectoryCleanup = new CommandDirectoryCleanup();
            baseDir = commandDirectoryCleanup.CommandDirectory.BaseDir;
            var installer = new Installer(commandDirectoryCleanup.CommandDirectory);
            var installed = await installer.InstallAsync(packageName, null, force : false, includePreRelease : false);

            installed.Should().BeTrue();
            uninstaller = new Uninstaller(commandDirectoryCleanup.CommandDirectory);
            uninstalled = await uninstaller.UninstallAsync(packageName);

            uninstalled.Should().BeTrue();
        }
Пример #17
0
        /// <summary>
        /// Uninstall Package - Before Delete (Old style events, no V6/V7 equivelant)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void InstalledPackage_BeforeDelete(InstalledPackage sender, System.EventArgs e)
        {
            //Check which package is being uninstalled
            if (sender.Data.Name != "Promote")
            {
                return;
            }

            //Start Uninstall - clean up process...
            Uninstaller.RemoveSectionDashboard();

            //Remove AppSetting key when all done
            Configuration webConfig = WebConfigurationManager.OpenWebConfiguration("/");

            webConfig.AppSettings.Settings.Remove(AppSettingKey);
            webConfig.Save();
        }
        public async Task UninstallsClickOnceApp()
        {
            var installer = new ClickOnceInstaller();
            await installer.InstallClickOnceApp(new Uri(IntegrationTestHelper.ClickOnceTestAppPath));

            UninstallInfo theApp = UninstallInfo.Find(IntegrationTestHelper.ClickOnceAppName);

            Assert.NotNull(theApp);

            var uninstaller = new Uninstaller();

            uninstaller.Uninstall(theApp);

            UninstallInfo shouldBeNull = UninstallInfo.Find(IntegrationTestHelper.ClickOnceAppName);

            Assert.Null(shouldBeNull);
        }
Пример #19
0
        public override IEnumerable <JunkNode> FindJunk()
        {
            var output = new List <DriveJunkNode>();

            var uninLoc = Uninstaller.UninstallerLocation;

            if (uninLoc.IsNotEmpty() &&
                UninstallToolsGlobalConfig.GetAllProgramFiles().Any(
                    x => uninLoc.StartsWith(x, StringComparison.InvariantCultureIgnoreCase)) &&
                !OtherInstallLocations.Any(x => uninLoc.StartsWith(x, StringComparison.InvariantCultureIgnoreCase) || x.StartsWith(uninLoc, StringComparison.InvariantCultureIgnoreCase)))
            {
                var resultNode = GetJunkNodeFromLocation(uninLoc);
                if (resultNode != null)
                {
                    output.Add(resultNode);
                }
            }

            if (Uninstaller.IsInstallLocationValid())
            {
                var resultNode = GetJunkNodeFromLocation(Uninstaller.InstallLocation);
                if (resultNode != null)
                {
                    output.Add(resultNode);
                }
            }

            output.AddRange(GetUninstallerJunk());

            foreach (var folder in FoldersToCheck)
            {
                output.AddRange(FindJunkRecursively(folder));
            }

            if (Uninstaller.UninstallerKind == UninstallerType.StoreApp)
            {
                foreach (var driveJunkNode in output)
                {
                    driveJunkNode.Confidence.Add(ConfidencePart.IsStoreApp);
                }
            }

            output.AddRange(SearchWerReports());

            return(RemoveDuplicates(output).Cast <JunkNode>());
        }
Пример #20
0
        private void BeginInstall()
        {
            progressBar.Value   = 0;
            progressBar.Maximum = UNINSTALL_TICKS;

            new Task(new Action(() => {
                IntPtr redirection = RedirectionManager.DisableRedirection();

                try {
                    Uninstaller.Uninstall(this);
                    Complete();
                } catch (Exception e) {
                    Failure(e);
                } finally {
                    RedirectionManager.EnableRedirection(redirection);
                }
            })).Start();
        }
 private void Btn_Uninstall_Click(object sender, EventArgs e)
 {
     if (!Directory.Exists(Txt_InstallLocation.Text))
     {
         MessageBox.Show("Install Location does not exist");
     }
     else if (!ChBox_SaveData.Checked)
     {
         Uninstaller.UninstallApp(Shortcuts, Txt_InstallLocation.Text);
         MessageBox.Show("Application successfully uninstalled");
     }
     else if (Directory.Exists(Txt_SaveLocation.Text) || (!Directory.Exists(Txt_SaveLocation.Text) &&
                                                          MessageBox.Show("Save Folder does not exist so installer will need to create one. Continue?", "Uninstall", MessageBoxButtons.YesNo) == DialogResult.Yes))
     {
         Uninstaller.MoveApp(Shortcuts, Txt_InstallLocation.Text, Txt_SaveLocation.Text);
         MessageBox.Show("Application successfully saved to save location");
     }
 }
Пример #22
0
        private void FlatButtonUninstall_Click(object sender, EventArgs e)
        {
            if (!_successfulUninstall)
            {
                timerCheckRunning.Stop();

                labelProgress.Text       = "Uninstalling";
                progressBarInstall.Value = 0;
                progressBarInstall.SetState(1);
                progressBarInstall.Style = ProgressBarStyle.Marquee;

                flatButtonUninstall.Enabled = false;
                flatButtonUninstallCancel.Hide();
                borderPanelProgressInstall.Show();

                Timer t = new Timer()
                {
                    Interval = 1000
                };
                t.Tick += delegate
                {
                    _uninstaller = new Uninstaller(_config);

                    progressBarInstall.Style = ProgressBarStyle.Continuous;

                    var worker = new BackgroundWorker();
                    worker.ProgressChanged    += Worker_ProgressChanged;
                    worker.RunWorkerCompleted += Worker_RunWorkerCompleted;

                    _uninstaller.Start(worker);

                    t.Stop();
                    t.Dispose();
                };
                t.Start();
            }
            else
            {
                RemoveArtifact();
                _navigator.CancelInstall();
            }
        }
        public override IEnumerable <JunkNode> FindJunk()
        {
            var softwareKeys = GetSoftwareRegKeys(Uninstaller.Is64Bit);
            var returnList   = new List <RegistryJunkNode>();

            foreach (var softwareKey in softwareKeys)
            {
                FindJunkRecursively(returnList, softwareKey, 0);
            }

            if (Uninstaller.RegKeyStillExists())
            {
                var regKeyNode = new RegistryJunkNode(PathTools.GetDirectory(Uninstaller.RegistryPath),
                                                      Uninstaller.RegistryKeyName, Uninstaller.DisplayName);
                regKeyNode.Confidence.Add(ConfidencePart.IsUninstallerRegistryKey);
                returnList.Add(regKeyNode);
            }

            return(returnList.Cast <JunkNode>());
        }
Пример #24
0
        public static IDisposable WithClickOnceApp()
        {
            string clickOnceApp = Path.Combine(new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.FullName, "ClickOnceApp/ClickOnceApp.application"); // omg
            var    installer    = new ClickOnceInstaller();

            installer.InstallClickOnceApp(new Uri(clickOnceApp)).Wait();

            return(Disposable.Create(() =>
            {
                UninstallInfo theApp = UninstallInfo.Find(ClickOnceAppName);

                if (theApp == null)
                {
                    return;
                }

                var uninstaller = new Uninstaller();
                uninstaller.Uninstall(theApp);
            }));
        }
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            string installPath = (string)Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\" + installedPathRegKeyName, "InstallPath", "") ?? "";

            // get system display language
            string displayLanguage = CultureInfo.InstalledUICulture.TwoLetterISOLanguageName;

            // import strings.json from resources and parse it into a JObject


            state = InstallerState.Read(installPath);
            state.Update();
            if (e.Args.Length > 0 && e.Args[0] == "/uninstall")
            {
                if (MessageBox.Show("Are you sure you want to uninstall KinectToVR?", "Confirm", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    try {
                        if (Uninstaller.UninstallK2EX(installPath))
                        {
                            MessageBox.Show("Uninstalled successfully!");
                            if (Directory.Exists(installPath))
                            {
                                // https://stackoverflow.com/a/1305478/
                                ProcessStartInfo Info = new ProcessStartInfo();
                                Info.Arguments      = "/C choice /C Y /N /D Y /T 3 & rmdir /S /Q \"" + installPath + "\"";
                                Info.WindowStyle    = ProcessWindowStyle.Hidden;
                                Info.CreateNoWindow = true;
                                Info.FileName       = "cmd.exe";
                                Process.Start(Info);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show("An error happened while trying to uninstall. Join our Discord for help on manually uninstalling.");
                        new ExceptionDialog(ex).ShowDialog();
                    }
                }
                Current.Shutdown(0);
            }
        }
Пример #26
0
        public override async Task ExecuteCommandAsync()
        {
            if (!this.IsValid)
            {
                return;
            }

            ConsolePathMapper.SetPathToRoot();

            try
            {
                new ApprovedDomainSerializer().Add
                (
                    new ApprovedDomain
                {
                    DomainName                 = this.DomainName,
                    DbProvider                 = this.ProviderName,
                    Synonyms                   = new string[0],
                    BackupDirectory            = string.Empty,
                    AdminEmail                 = string.Empty,
                    EnforceSsl                 = false,
                    BackupDirectoryIsFixedPath = false,
                    CdnDomain                  = string.Empty
                });


                var installer = new Tenant.Installer(this.DomainName);
                await installer.InstallAsync().ConfigureAwait(false);
            }
            finally
            {
                if (this.CleanupWhenDone)
                {
                    var uninstaller = new Uninstaller(this.DomainName);
                    await uninstaller.UnInstallAsync().ConfigureAwait(false);
                }
            }
        }
        public async Task UninstallsClickOnceApp()
        {
            var installer = new ClickOnceInstaller();
            await installer.InstallClickOnceApp(new Uri(IntegrationTestHelper.ClickOnceTestAppPath));

            UninstallInfo theApp = UninstallInfo.Find(IntegrationTestHelper.ClickOnceAppName);

            Assert.NotNull(theApp);

            var uninstaller = new Uninstaller();
            uninstaller.Uninstall(theApp);

            UninstallInfo shouldBeNull = UninstallInfo.Find(IntegrationTestHelper.ClickOnceAppName);

            Assert.Null(shouldBeNull);
        }
Пример #28
0
        async Task CheckForUpdates()
        {
            try
            {
                if (Config.Default.settings.update.isDisabled)
                {
                    Trace.TraceInformation("The software update check is disabled by the user; skipping check");
                    return;
                }

                // Remove any old ClickOnce installs
                try
                {
                    var uninstallInfo = UninstallInfo.Find("IPFilter Updater");
                    if (uninstallInfo != null)
                    {
                        Trace.TraceWarning("Old ClickOnce app installed! Trying to remove...");
                        var uninstaller = new Uninstaller();
                        uninstaller.Uninstall(uninstallInfo);
                        Trace.TraceInformation("Successfully removed ClickOnce app");
                    }
                }
                catch (Exception ex)
                {
                    Trace.TraceError("Failed to remove old ClickOnce app: " + ex);
                }

                var applicationDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "IPFilter");
                var installerDir         = new DirectoryInfo(Path.Combine(applicationDirectory, "installer"));

                // Detect the current running version. The ProductVersion contains the informational, semantic version e.g. "3.0.0-beta"
                var versionInfo    = Process.GetCurrentProcess().MainModule.FileVersionInfo;
                var currentVersion = new SemanticVersion(versionInfo.ProductVersion);

                // Remove any old installers
                try
                {
                    if (!installerDir.Exists)
                    {
                        installerDir.Create();
                    }
                    else if (!Config.Default.settings.update.isCleanupDisabled)
                    {
                        // Don't delete the MSI for the current installed version
                        var currentMsiName = "IPFilter." + currentVersion.ToNormalizedString() + ".msi";

                        // Scan the directory for all installers
                        foreach (var fileInfo in installerDir.GetFiles("IPFilter.*.msi"))
                        {
                            // Don't remove the installer for the installed version
                            if (fileInfo.Name.Equals(currentMsiName, StringComparison.OrdinalIgnoreCase))
                            {
                                continue;
                            }

                            Trace.TraceInformation("Removing cached installer: " + fileInfo.Name);
                            fileInfo.SafeDelete();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Trace.TraceError("Couldn't clean up old installers: " + ex);
                }

                Trace.TraceInformation("Checking for software updates...");
                progress.Report(new ProgressModel(UpdateState.Downloading, "Checking for software updates...", -1));

                var updater = new Updater();

                var result = await updater.CheckForUpdateAsync(Config.Default.settings.update.isPreReleaseEnabled);

                if (result == null)
                {
                    return;
                }

                var latestVersion = new SemanticVersion(result.Version);

                Update.IsUpdateAvailable = latestVersion > currentVersion;

                if (Update.IsUpdateAvailable)
                {
                    Update.AvailableVersion       = latestVersion;
                    Update.IsUpdateRequired       = true;
                    Update.MinimumRequiredVersion = latestVersion;
                    Update.UpdateSizeBytes        = 2000000;
                }

                Trace.TraceInformation("Current version: {0}", Update.CurrentVersion);
                Trace.TraceInformation("Available version: {0}", Update.AvailableVersion?.ToString() ?? "<no updates>");

                if (!Update.IsUpdateAvailable)
                {
                    return;
                }

                if (MessageBoxHelper.Show(dispatcher, "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.Yes,
                                          "An update to version {0} is available. Would you like to update now?", Update.AvailableVersion) != MessageBoxResult.Yes)
                {
                    return;
                }

                Trace.TraceInformation("Starting application update...");

                // If we're not "installed", then don't check for updates. This is so the
                // executable can be stand-alone. Stand-alone self-update to come later.
                using (var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\IPFilter"))
                {
                    var installPath = (string)key?.GetValue("InstallPath");
                    if (installPath == null)
                    {
                        using (var process = new Process())
                        {
                            process.StartInfo = new ProcessStartInfo("https://www.ipfilter.app/")
                            {
                                UseShellExecute = true
                            };

                            process.Start();
                            return;
                        }
                    }
                }

                // Download the MSI to the installer directory
                var msiPath = Path.Combine(installerDir.FullName, "IPFilter." + Update.AvailableVersion + ".msi");

                // Download the installer
                using (var handler = new WebRequestHandler())
                {
                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;

                    var uri = new Uri($"{result.Uri}?{DateTime.Now.ToString("yyyyMMddHHmmss")}");

                    using (var httpClient = new HttpClient(handler))
                        using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken.Token))
                        {
                            if (cancellationToken.IsCancellationRequested)
                            {
                                progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
                                Update.IsUpdating = false;
                                return;
                            }

                            var    length          = response.Content.Headers.ContentLength;
                            double lengthInMb      = !length.HasValue ? -1 : (double)length.Value / 1024 / 1024;
                            double bytesDownloaded = 0;

                            using (var stream = await response.Content.ReadAsStreamAsync())
                                using (var msi = File.Open(msiPath, FileMode.Create, FileAccess.Write, FileShare.Read))
                                {
                                    var buffer = new byte[65535 * 4];

                                    int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);

                                    while (bytesRead != 0)
                                    {
                                        await msi.WriteAsync(buffer, 0, bytesRead, cancellationToken.Token);

                                        bytesDownloaded += bytesRead;

                                        if (length.HasValue)
                                        {
                                            double downloadedMegs = bytesDownloaded / 1024 / 1024;
                                            var    percent        = (int)Math.Floor((bytesDownloaded / length.Value) * 100);

                                            var status = string.Format(CultureInfo.CurrentUICulture, "Downloaded {0:F2} MB of {1:F2} MB", downloadedMegs, lengthInMb);

                                            Update.IsUpdating         = true;
                                            Update.DownloadPercentage = percent;
                                            progress.Report(new ProgressModel(UpdateState.Downloading, status, percent));
                                        }

                                        if (cancellationToken.IsCancellationRequested)
                                        {
                                            progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
                                            Update.IsUpdating = false;
                                            return;
                                        }

                                        bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
                                    }
                                }
                        }
                }

                progress.Report(new ProgressModel(UpdateState.Ready, "Launching update...", 100));
                Update.IsUpdating = false;

                // Now run the installer
                var sb = new StringBuilder("msiexec.exe ");

                // Enable logging for the installer
                var installLog = Path.Combine(applicationDirectory, "install.log");
                sb.AppendFormat(" /l*v \"{0}\"", installLog);

                sb.AppendFormat(" /i \"{0}\"", msiPath);

                //sb.Append(" /passive");

                ProcessInformation processInformation = new ProcessInformation();
                StartupInfo        startupInfo        = new StartupInfo();
                SecurityAttributes processSecurity    = new SecurityAttributes();
                SecurityAttributes threadSecurity     = new SecurityAttributes();
                processSecurity.nLength = Marshal.SizeOf(processSecurity);
                threadSecurity.nLength  = Marshal.SizeOf(threadSecurity);

                const int NormalPriorityClass = 0x0020;

                if (!ProcessManager.CreateProcess(null, sb, processSecurity,
                                                  threadSecurity, false, NormalPriorityClass,
                                                  IntPtr.Zero, null, startupInfo, processInformation))
                {
                    throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
                }

                try
                {
                    //dispatcher.Invoke(DispatcherPriority.Normal, new Action(Application.Current.Shutdown));
                    Application.Current.Shutdown();
                }
                catch (Exception ex)
                {
                    Trace.TraceError("Exception when shutting down app for update: " + ex);
                    Update.ErrorMessage = "Couldn't shutdown the app to apply update.";
                }
            }
            catch (Exception ex)
            {
                Trace.TraceWarning("Application update check failed: " + ex);
            }
            finally
            {
                progress.Report(new ProgressModel(UpdateState.Ready, "Ready", 0));
            }
        }
Пример #29
0
        /// <summary>
        ///     Backend input
        /// </summary>
        /// <param name="inputargs">Input</param>
        public static void doCommand(string[] inputargs)
        {
            switch (inputargs[0])
            {
            case "reload":
                JsonModList.GetModLists(true);
                break;

            case "wipe":
                File.Delete(Directory.GetCurrentDirectory() + @"\installedmods.json");
                Console.WriteLine("Wiped!");
                break;

            case "modlists":
                listmodlists();
                break;

            case "check":

                var ml = JsonModList.GetModLists();

                for (var i = 0; i < ml.Length; i++)
                {
                    for (var x = 0; x < ml[i].Modlist.Length; x++)
                    {
                        if (ml[i].Modlist[x].ModId == inputargs[1])
                        {
                            var link = ml[i].Modlist[x].Website;
                            var psi  = new ProcessStartInfo
                            {
                                FileName        = link,
                                UseShellExecute = true
                            };
                            Process.Start(psi);
                        }
                    }
                }

                break;

            case "dl":
                Downloader.DownloadModDirector(inputargs[1]);
                break;

            case "install":
                Downloader.DownloadModDirector(inputargs[1], true);
                break;

            case "list":
                if (inputargs[1] == "installedmods")
                {
                    var mf = InstalledMods.GetInstalledMods();
                    for (var i = 0; i < mf.Length; i++)
                    {
                        Console.WriteLine(mf[i].Name);
                    }
                }
                else
                {
                    list(inputargs[1]);
                }

                break;

            case "exit":
                return;

            case "help":
                Console.WriteLine("wipe - Wipes the installed registry (DOES NOT DELETE MODS)");
                Console.WriteLine("modlists - Lists all modlists, which are lists of mods.");
                Console.WriteLine("dl [modname] - Downloads mod listed.");
                Console.WriteLine("check [modname] - Opens browser to modpage.");
                Console.WriteLine("list [modlist] - Lists all mods contained in a modlist.");
                Console.WriteLine("list installedmods - Lists all mods registered as installed.");
                Console.WriteLine("exit - Close H3VRModInstaller.");
                break;

            case "toggledebugging":
                ModInstallerCommon.enableDebugging = !ModInstallerCommon.enableDebugging;
                Console.WriteLine("Debugging is now " + ModInstallerCommon.enableDebugging);
                break;

            //deletion
            case "rm":
                Console.WriteLine($"Deleting {inputargs[1]}");
                Uninstaller.DeleteMod(inputargs[1]);
                break;

            default:
                Console.WriteLine("Invalid command!");
                break;
            }
        }
Пример #30
0
        async Task CheckForUpdates()
        {
            try
            {
                // Remove any old ClickOnce installs
                try
                {
                    var uninstallInfo = UninstallInfo.Find("IPFilter Updater");
                    if (uninstallInfo != null)
                    {
                        Trace.TraceWarning("Old ClickOnce app installed! Trying to remove...");
                            var uninstaller = new Uninstaller();
                            uninstaller.Uninstall(uninstallInfo);
                            Trace.TraceInformation("Successfully removed ClickOnce app");
                    }
                }
                catch (Exception ex)
                {
                    Trace.TraceError("Failed to remove old ClickOnce app: " + ex);
                    telemetryClient?.TrackException(ex);
                }

                Trace.TraceInformation("Checking for software updates...");
                progress.Report(new ProgressModel(UpdateState.Downloading, "Checking for software updates...", -1));

                var updater = new Updater();

                var result = await updater.CheckForUpdateAsync();

                var currentVersion = new Version(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion);

                var latestVersion = new Version(result.Version);
                
                Update.IsUpdateAvailable = latestVersion > currentVersion;

                if (Update.IsUpdateAvailable)
                {
                    Update.AvailableVersion = latestVersion;
                    Update.IsUpdateRequired = true;
                    Update.MinimumRequiredVersion = latestVersion;
                    Update.UpdateSizeBytes = 2000000;
                }

                Trace.TraceInformation("Current version: {0}", Update.CurrentVersion);
                Trace.TraceInformation("Available version: {0}", Update.AvailableVersion?.ToString() ?? "<no updates>");

                if (!Update.IsUpdateAvailable ) return;
                
                if (MessageBoxHelper.Show(dispatcher, "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.Yes,
                    "An update to version {0} is available. Would you like to update now?", Update.AvailableVersion) != MessageBoxResult.Yes)
                {
                    return;
                }
                
                Trace.TraceInformation("Starting application update...");

                // If we're not "installed", then don't check for updates. This is so the
                // executable can be stand-alone. Stand-alone self-update to come later.
                using (var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\IPFilter"))
                {
                    var installPath = (string) key?.GetValue("InstallPath");
                    if (installPath == null)
                    {
                        using (var process = new Process())
                        {
                            process.StartInfo = new ProcessStartInfo("https://davidmoore.github.io/ipfilter/")
                            {
                                UseShellExecute = true
                            };

                            process.Start();
                            return;
                        }
                    }
                }

                var msiPath = Path.Combine(Path.GetTempPath(), "IPFilter.msi");

                // Download the installer
                using (var handler = new WebRequestHandler())
                {
                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;

                    var uri = new Uri($"{result.Uri}?{DateTime.Now.ToString("yyyyMMddHHmmss")}");

                    using (var httpClient = new HttpClient(handler))
                    using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken.Token))
                    {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
                            Update.IsUpdating = false;
                            return;
                        }

                        var length = response.Content.Headers.ContentLength;
                        double lengthInMb = !length.HasValue ? -1 : (double)length.Value / 1024 / 1024;
                        double bytesDownloaded = 0;

                        using(var stream = await response.Content.ReadAsStreamAsync())
                        using(var msi = File.Open( msiPath, FileMode.Create, FileAccess.Write, FileShare.Read))
                        {
                            var buffer = new byte[65535 * 4];

                            int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
                            while (bytesRead != 0)
                            {
                                await msi.WriteAsync(buffer, 0, bytesRead, cancellationToken.Token);
                                bytesDownloaded += bytesRead;

                                if (length.HasValue)
                                {
                                    double downloadedMegs = bytesDownloaded / 1024 / 1024;
                                    var percent = (int)Math.Floor((bytesDownloaded / length.Value) * 100);

                                    var status = string.Format(CultureInfo.CurrentUICulture, "Downloaded {0:F2} MB of {1:F2} MB", downloadedMegs, lengthInMb);

                                    Update.IsUpdating = true;
                                    Update.DownloadPercentage = percent;
                                    progress.Report(new ProgressModel(UpdateState.Downloading, status, percent));
                                }

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
                                    Update.IsUpdating = false;
                                    return;
                                }

                                bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
                            }
                        }
                    }
                }

                progress.Report(new ProgressModel(UpdateState.Ready, "Launching update...", 100));
                Update.IsUpdating = false;
                
                // Now run the installer
                var sb = new StringBuilder("msiexec.exe ");

                // Enable logging for the installer
                sb.AppendFormat(" /l*v \"{0}\"", Path.Combine(Path.GetTempPath(), "IPFilter.log"));
                
                sb.AppendFormat(" /i \"{0}\"", msiPath);

                //sb.Append(" /passive");

                ProcessInformation processInformation = new ProcessInformation();
                StartupInfo startupInfo = new StartupInfo();
                SecurityAttributes processSecurity = new SecurityAttributes();
                SecurityAttributes threadSecurity = new SecurityAttributes();
                processSecurity.nLength = Marshal.SizeOf(processSecurity);
                threadSecurity.nLength = Marshal.SizeOf(threadSecurity);

                const int NormalPriorityClass = 0x0020;

                if (!ProcessManager.CreateProcess(null, sb, processSecurity,
                    threadSecurity, false, NormalPriorityClass,
                    IntPtr.Zero, null, startupInfo, processInformation))
                {
                    throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
                }
                
                try
                {
                    //dispatcher.Invoke(DispatcherPriority.Normal, new Action(Application.Current.Shutdown));
                    Application.Current.Shutdown();
                }
                catch (Exception ex)
                {
                    Trace.TraceError("Exception when shutting down app for update: " + ex);
                    Update.ErrorMessage = "Couldn't shutdown the app to apply update.";
                    telemetryClient?.TrackException(ex);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceWarning("Application update check failed: " + ex);
                telemetryClient?.TrackException(ex);
                telemetryClient?.Flush();
            }
            finally
            {
                progress.Report(new ProgressModel(UpdateState.Ready, "Ready", 0));
            }
        }
Пример #31
0
        #pragma warning restore 1998

        public async Task Uninstall(IProgress <Tuple <int, string> > progress = null, bool dryRun = true)
        {
            await Uninstaller.Run(progress, dryRun);
        }
Пример #32
0
        public async void OnSelected()
        {
            await Task.Run(() =>
            {
                Log("K2EX Installer " + Assembly.GetExecutingAssembly().GetName().Version.ToString() + " on " + DateTime.Now.ToString());

                Log("Checking if SteamVR is open...", false);
                foreach (Process process in Process.GetProcesses())
                {
                    if (process.ProcessName == "vrmonitor")
                    {
                        Log("Closing vrmonitor...", false);
                        process.CloseMainWindow();
                        Thread.Sleep(5000);
                        if (!process.HasExited)
                        {
                            Log("Force closing...", false);

                            /* When SteamVR is open with no headset detected,
                             * CloseMainWindow will only close the "headset not found" popup
                             * so we kill it, if it's still open */
                            process.Kill();
                            Thread.Sleep(3000);
                        }
                    }
                }

                /* Apparently, SteamVR server can run without the monitor,
                 * so we close that, if it's open as well (monitor will complain if you close server first) */
                foreach (Process process in Process.GetProcesses())
                {
                    if (process.ProcessName == "vrserver")
                    {
                        Log("Closing vrserver...", false);
                        // CloseMainWindow won't work here because it doesn't have a window
                        process.Kill();
                        Thread.Sleep(5000);
                        if (!process.HasExited)
                        {
                            MessageBox.Show(Properties.Resources.install_steamvr_close_failed);
                            Cancel();
                            return;
                        }
                    }
                }
                Log("Done!");

                Log("Checking for legacy installations...", false);
                Uninstaller.UninstallK2VrLegacy(this);

                Log("Checking for other K2EX installations...", false);
                try
                {
                    if (!Uninstaller.UninstallAllK2EX(this))
                    {
                        return;
                    }
                }
                catch (Exception e)
                {
                    Dispatcher.Invoke(() =>
                    {
                        if (new ExceptionDialog(e, true).ShowDialog().Value != true)
                        {
                            Application.Current.Shutdown(1);
                        }
                    });
                }
                Log("Done!");

                Log("Checking install directory...", false);
                bool dirExists = Directory.Exists(App.state.GetFullInstallationPath());
                Log("Done!");
                Log("Creating install directory...", false);
                if (!dirExists)
                {
                    Directory.CreateDirectory(App.state.GetFullInstallationPath());
                }
                Log("Done!");

                Log("Extracting OpenVR driver...", false);
                string zipFileName = Path.Combine(App.downloadDirectory + FileDownloader.files["k2vr"].OutName);
                using (ZipArchive archive = ZipFile.OpenRead(zipFileName))
                {
                    foreach (ZipArchiveEntry entry in archive.Entries)
                    {
                        string newName  = entry.FullName.Substring("K2EX/".Length); // Remove the top level folder
                        string fullPath = Path.GetFullPath(Path.Combine(App.state.GetFullInstallationPath(), newName));
                        if (fullPath.EndsWith(@"\", StringComparison.Ordinal))
                        {
                            Directory.CreateDirectory(fullPath);
                            App.state.installedFolders.Add(fullPath);
                        }
                        else
                        {
                            entry.ExtractToFile(fullPath, true);
                            App.state.installedFiles.Add(fullPath);
                        }
                    }
                }
                Log("Done!");

                Log("Registering application...", false);
                App.state.Write();
                // we need to manually set file attribs before copying.
                File.SetAttributes(Path.Combine(App.state.GetFullInstallationPath(), "k2vr-installer-gui.exe"), FileAttributes.Normal);
                File.Copy(Assembly.GetExecutingAssembly().Location, Path.Combine(App.state.GetFullInstallationPath(), "k2vr-installer-gui.exe"), true);
                Uninstaller.RegisterUninstaller();

                if ((App.state.trackingDevice == InstallerState.TrackingDevice.Xbox360Kinect && !App.state.kinectV1SdkInstalled) ||
                    (App.state.trackingDevice == InstallerState.TrackingDevice.XboxOneKinect && !App.state.kinectV2SdkInstalled))
                {
                    Log("Installing the Kinect SDK...", false);
                    string sdkInstaller         = Path.Combine(App.downloadDirectory, FileDownloader.files[(App.state.trackingDevice == InstallerState.TrackingDevice.Xbox360Kinect) ? "kinect_v1_sdk" : "kinect_v2_sdk"].OutName);
                    Process sdkInstallerProcess = Process.Start(sdkInstaller);
                    Thread.Sleep(1000);
                    try
                    {
                        // https://stackoverflow.com/a/3734322/
                        AutomationElement element = AutomationElement.FromHandle(sdkInstallerProcess.MainWindowHandle);
                        if (element != null)
                        {
                            element.SetFocus();
                        }
                    }
                    catch (Exception) { } // Don't want the whole install to fail for something that mundane
                    sdkInstallerProcess.WaitForExit();

                    App.state.UpdateSdkInstalled();

                    if ((App.state.trackingDevice == InstallerState.TrackingDevice.Xbox360Kinect && !App.state.kinectV1SdkInstalled) ||
                        (App.state.trackingDevice == InstallerState.TrackingDevice.XboxOneKinect && !App.state.kinectV2SdkInstalled))
                    {
                        Log("Failed!");
                        MessageBox.Show(Properties.Resources.install_sdk_failed);
                        Cancel();
                        return;
                    }
                    Log("Done!");
                }
                else
                {
                    Log("Kinect SDK is already installed.");
                }

                Log("Installing Visual C++ Redistributable...", false);
                string vcRedistPath = Path.Combine(App.downloadDirectory, FileDownloader.files["vc_redist2019"].OutName);
                Process.Start(vcRedistPath, "/quiet /norestart").WaitForExit();
                Log("Done!");

                Log("Registering OpenVR driver...", false);
                string driverPath = Path.Combine(App.state.GetFullInstallationPath(), "KinectToVR");
                Process.Start(App.state.vrPathReg, "adddriver \"" + driverPath + "\"").WaitForExit();
                Log("Checking...", false);
                var openVrPaths = OpenVrPaths.Read();
                if (!openVrPaths.external_drivers.Contains(driverPath))
                {
                    Log("Copying...", false);
                    CopyFilesRecursively(new DirectoryInfo(driverPath), new DirectoryInfo(App.state.copiedDriverPath));
                }
                Log("Done!");

                string kinectProcessName = "KinectV" + (App.state.trackingDevice == InstallerState.TrackingDevice.XboxOneKinect ? "2" : "1") + "Process";

                Log("Registering OpenVR overlay...", false);

                var appConfig       = AppConfig.Read();
                string manifestPath = Path.Combine(App.state.GetFullInstallationPath(), kinectProcessName + ".vrmanifest");
                if (!appConfig.manifest_paths.Contains(manifestPath))
                {
                    appConfig.manifest_paths.Add(manifestPath);
                    appConfig.Write();
                    Log("Done!");
                }
                else
                {
                    Log("Already done!");
                }

                Log("Disabling SteamVR Home, enabling advanced settings...", false);
                var steamVrSettings = JsonConvert.DeserializeObject <dynamic>(File.ReadAllText(App.state.steamVrSettingsPath));
                try
                {
                    steamVrSettings["steamvr"]["enableHomeApp"]        = false;
                    steamVrSettings["steamvr"]["showAdvancedSettings"] = true;
                    JsonFile.Write(App.state.steamVrSettingsPath, steamVrSettings, 3, ' ');
                    Log("Done!");
                }
                catch (Exception)
                {
                    Log("Failed (uncritical)!");
                }
                Log("Registering tracker roles...", false);
                try
                {
                    if (steamVrSettings["trackers"] == null)
                    {
                        steamVrSettings["trackers"] = new JObject();
                    }
                    steamVrSettings["trackers"]["/devices/htc/vive_trackerLHR-CB11ABEC"] = "TrackerRole_Waist";
                    steamVrSettings["trackers"]["/devices/htc/vive_trackerLHR-CB1441A7"] = "TrackerRole_RightFoot";
                    steamVrSettings["trackers"]["/devices/htc/vive_trackerLHR-CB9AD1T2"] = "TrackerRole_LeftFoot";
                    JsonFile.Write(App.state.steamVrSettingsPath, steamVrSettings, 3, ' ');
                    Log("Done!");
                }
                catch (Exception)
                {
                    Log("Failed (uncritical)!");
                }
                Log("Enabling driver in SteamVR...", false);
                try
                {
                    if (steamVrSettings["driver_kinecttovr"] == null)
                    {
                        steamVrSettings["driver_kinecttovr"] = new JObject();
                    }
                    steamVrSettings["driver_kinecttovr"]["enable"] = true;
                    steamVrSettings["driver_kinecttovr"]["blocked_by_safe_mode"] = false;
                    JsonFile.Write(App.state.steamVrSettingsPath, steamVrSettings, 3, ' ');
                    Log("Done!");
                }
                catch (Exception)
                {
                    Log("Failed (uncritical)!");
                }

                Log("Creating start menu entry...", false);
                if (!Directory.Exists(App.startMenuFolder))
                {
                    Directory.CreateDirectory(App.startMenuFolder);
                }
                // https://stackoverflow.com/a/4909475/
                var shell = new IWshRuntimeLibrary.WshShell();
                string shortcutAddress    = Path.Combine(App.startMenuFolder, "KinectToVR.lnk");
                var shortcut              = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(shortcutAddress);
                shortcut.Description      = "Launch KinectToVR";
                shortcut.TargetPath       = Path.Combine(App.state.GetFullInstallationPath(), kinectProcessName + ".exe");
                shortcut.IconLocation     = Path.Combine(App.state.GetFullInstallationPath(), "k2vr.ico");
                shortcut.WorkingDirectory = Path.Combine(App.state.GetFullInstallationPath());
                shortcut.Save();
                Log("Refreshing...", false);
                foreach (Process process in Process.GetProcesses())
                {
                    if (process.ProcessName == "StartMenuExperienceHost")
                    {
                        process.Kill();
                        Thread.Sleep(500);
                    }
                }
                Log("Done!");

                Log("Installation complete!");
                Log("The installation log can be found in \"" + App.downloadDirectory + "\"", false);
                Button_Complete_Install.Dispatcher.Invoke(() =>
                {
                    Button_Complete_Install.IsEnabled = true;
                });
            });
        }
Пример #33
0
        void uninstall(object sender, DoWorkEventArgs e)
        {
            if (!OsuMain.IsElevated)
            {
                OsuMain.Elevate(@"-uninstall", false);
                return;
            }

            try
            {
                init();
                setProgress(0, OsuString.Maintenance_Bye);

                int seconds = 10;
                while (seconds > 0)
                {
                    setText(string.Format(LocalisationManager.GetString(OsuString.Maintenance_Uninstall) + '\n' +
                                          LocalisationManager.GetString(OsuString.Maintenance_Uninstall2), seconds), true);
                    Thread.Sleep(1000);
                    seconds--;

                    while (installPath == null)
                    {
                        Thread.Sleep(100);
                    }
                }

                setText(LocalisationManager.GetString(OsuString.Maintenance_Uninstalling), true);

                string[] directories = Directory.GetDirectories(Environment.CurrentDirectory);

                int totalProgressItems = directories.Length + 8;
                int currentProgress    = 0;

                //delete subdirectories
                foreach (string dir in directories)
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    try
                    {
                        Directory.Delete(dir, true);
                    }
                    catch
                    {
                    }

                    Thread.Sleep(100);
                }

                //delete main directory
                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    Directory.Delete(Environment.CurrentDirectory, true);
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    foreach (string file in Directory.GetFiles(Environment.CurrentDirectory))
                    {
                        GeneralHelper.FileDeleteOnReboot(file);
                    }
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    Directory.Delete(Environment.CurrentDirectory);
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    GeneralHelper.FileDeleteOnReboot(Environment.CurrentDirectory);
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    Uninstaller.RemoveUninstaller();
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    File.Delete(icon_path_desktop);
                    File.Delete(icon_path_startmenu);
                }
                catch
                {
                }

                try
                {
                    setProgress((int)(((float)++currentProgress / totalProgressItems) * 100));
                    GeneralHelper.RegistryDelete(@"osu!");
                    GeneralHelper.RegistryDelete(@"osu");
                }
                catch
                {
                }

                setProgress(100);
                setText(LocalisationManager.GetString(OsuString.Maintenance_Farewell), true);
                Thread.Sleep(5000);
            }
            catch { }
        }