示例#1
0
        public async Task <CkanModule> TooManyModsProvide(TooManyModsProvideKraken kraken)
        {
            //We want LMtHIT to be the last user selection. If we alter this handling a too many provides
            // it needs to be reset so a potential second too many provides doesn't use the wrong mod.
            GUIMod mod;

            TaskCompletionSource <CkanModule> task = new TaskCompletionSource <CkanModule>();

            Util.Invoke(this, () =>
            {
                UpdateProvidedModsDialog(kraken, task);
                tabController.ShowTab("ChooseProvidedModsTabPage", 3);
                tabController.SetTabLock(true);
            });
            var module = await task.Task;

            if (module == null)
            {
                last_mod_to_have_install_toggled.TryPeek(out mod);
                MarkModForInstall(mod.Identifier, uncheck: true);
            }
            Util.Invoke(this, () =>
            {
                tabController.SetTabLock(false);

                tabController.HideTab("ChooseProvidedModsTabPage");

                tabController.ShowTab("ManageModsTabPage");
            });

            if (module != null)
            {
                MarkModForInstall(module.identifier);
            }

            last_mod_to_have_install_toggled.TryPop(out mod);
            return(module);
        }
示例#2
0
        private void ShowSelection(Dictionary <CkanModule, List <string> > selectable, bool suggest = false)
        {
            if (installCanceled)
            {
                return;
            }

            // If we're going to install something anyway, then don't list it in the
            // recommended list, since they can't de-select it anyway.
            // The ToList dance is because we need to modify the dictionary while iterating over it,
            // and C# doesn't like that.
            foreach (CkanModule module in selectable.Keys.ToList())
            {
                if (toInstall.Any(m => m.identifier == module.identifier))
                {
                    selectable.Remove(module);
                }
            }

            Dictionary <CkanModule, string> mods = GetShowableMods(selectable);

            // If there are any mods that would be recommended, prompt the user to make
            // selections.
            if (mods.Any())
            {
                Util.Invoke(this, () => UpdateRecommendedDialog(mods, suggest));

                tabController.ShowTab("ChooseRecommendedModsTabPage", 3);
                tabController.SetTabLock(true);

                lock (this)
                {
                    Monitor.Wait(this);
                }

                tabController.SetTabLock(false);
            }
        }
示例#3
0
        private void PostUpdateRepo(object sender, RunWorkerCompletedEventArgs e)
        {
            var resultPair = e.Result as KeyValuePair <RepoUpdateResult, Dictionary <string, bool> >?;
            RepoUpdateResult?         result     = resultPair?.Key;
            Dictionary <string, bool> oldModules = resultPair?.Value;

            switch (result)
            {
            case RepoUpdateResult.NoChanges:
                AddStatusMessage(Properties.Resources.MainRepoUpToDate);
                HideWaitDialog(true);
                // Load rows if grid empty, otherwise keep current
                if (ManageMods.ModGrid.Rows.Count < 1)
                {
                    ManageMods.UpdateModsList();
                }
                break;

            case RepoUpdateResult.Failed:
                AddStatusMessage(Properties.Resources.MainRepoFailed);
                HideWaitDialog(false);
                break;

            case RepoUpdateResult.Updated:
            default:
                ManageMods.UpdateModsList(oldModules);
                AddStatusMessage(Properties.Resources.MainRepoSuccess);
                ShowRefreshQuestion();
                HideWaitDialog(true);
                UpgradeNotification();
                break;
            }

            tabController.HideTab("WaitTabPage");
            Util.Invoke(this, SwitchEnabledState);
            Util.Invoke(this, RecreateDialogs);
            Util.Invoke(this, ManageMods.ModGrid.Select);
        }
示例#4
0
        public async Task <CkanModule> TooManyModsProvide(TooManyModsProvideKraken kraken)
        {
            // We want LMtHIT to be the last user selection. If we alter this handling a too many provides
            // it needs to be reset so a potential second too many provides doesn't use the wrong mod.
            GUIMod mod;

            var module = await TooManyModsProvideCore(kraken);

            if (module == null &&
                last_mod_to_have_install_toggled.TryPeek(out mod))
            {
                MarkModForInstall(mod.Identifier, true);
            }
            Util.Invoke(this, () =>
            {
                tabController.SetTabLock(false);
                tabController.HideTab("ChooseProvidedModsTabPage");
                tabController.ShowTab("ManageModsTabPage");
            });

            last_mod_to_have_install_toggled.TryPop(out mod);
            return(module);
        }
示例#5
0
        private void CurrentInstanceUpdated()
        {
            Util.Invoke(this, () =>
            {
                Text = $"CKAN {Meta.GetVersion()} - KSP {CurrentInstance.Version()}    --    {CurrentInstance.GameDir()}";
            });

            configuration = Configuration.LoadOrCreateConfiguration(
                Path.Combine(CurrentInstance.CkanDir(), "GUIConfig.xml")
                );

            if (CurrentInstance.CompatibleVersionsAreFromDifferentKsp)
            {
                new CompatibleKspVersionsDialog(CurrentInstance, !actuallyVisible)
                .ShowDialog();
            }

            UpdateModsList();
            ChangeSet = null;
            Conflicts = null;

            Filter((GUIModFilter)configuration.ActiveFilter);
        }
示例#6
0
        private void LabelsAfterUpdate(IEnumerable <GUIMod> mods)
        {
            Util.Invoke(Main.Instance, () =>
            {
                mods          = mods.Memoize();
                var notifLabs = mainModList.ModuleLabels.LabelsFor(CurrentInstance.Name)
                                .Where(l => l.NotifyOnChange)
                                .Memoize();
                var toNotif = mods
                              .Where(m =>
                                     notifLabs.Any(l =>
                                                   l.ModuleIdentifiers.Contains(m.Identifier)))
                              .Select(m => m.Name)
                              .Memoize();
                if (toNotif.Any())
                {
                    MessageBox.Show(
                        string.Format(
                            Properties.Resources.MainLabelsUpdateMessage,
                            string.Join("\r\n", toNotif)
                            ),
                        Properties.Resources.MainLabelsUpdateTitle,
                        MessageBoxButtons.OK
                        );
                }

                foreach (GUIMod mod in mods)
                {
                    foreach (ModuleLabel l in mainModList.ModuleLabels.LabelsFor(CurrentInstance.Name)
                             .Where(l => l.RemoveOnChange &&
                                    l.ModuleIdentifiers.Contains(mod.Identifier)))
                    {
                        l.Remove(mod.Identifier);
                    }
                }
            });
        }
示例#7
0
        private void PostInstallMods(object sender, RunWorkerCompletedEventArgs e)
        {
            KeyValuePair <bool, ModChanges> result = (KeyValuePair <bool, ModChanges>)e.Result;

            UpdateModsList(false, result.Value);

            tabController.SetTabLock(false);

            if (result.Key)
            {
                if (modChangedCallback != null)
                {
                    foreach (var mod in result.Value)
                    {
                        modChangedCallback(mod.Mod, mod.ChangeType);
                    }
                }

                // install successful
                AddStatusMessage("Success!");
                HideWaitDialog(true);
                tabController.HideTab("ChangesetTabPage");
                ApplyToolButton.Enabled = false;
            }
            else
            {
                // there was an error
                // rollback user's choices but stay on the log dialog
                AddStatusMessage("Error!");
                SetDescription("An error occurred, check the log for information");
                Util.Invoke(DialogProgressBar, () => DialogProgressBar.Style = ProgressBarStyle.Continuous);
                Util.Invoke(DialogProgressBar, () => DialogProgressBar.Value = 0);
            }

            Util.Invoke(this, () => Enabled = true);
            Util.Invoke(menuStrip1, () => menuStrip1.Enabled = true);
        }
示例#8
0
        public void CurrentInstanceUpdated()
        {
            Util.Invoke(this, () =>
            {
                Text = String.Format("CKAN {0} - KSP {1}    --    {2}", Meta.Version(), CurrentInstance.Version(),
                                     CurrentInstance.GameDir());
                KSPVersionLabel.Text = String.Format("Kerbal Space Program {0}", CurrentInstance.Version());
            });

            // Update the settings dialog to reflect the changes made.
            Util.Invoke(m_SettingsDialog, () =>
            {
                m_SettingsDialog.UpdateDialog();
            });

            m_Configuration = Configuration.LoadOrCreateConfiguration
                              (
                Path.Combine(CurrentInstance.GameDir(), "CKAN/GUIConfig.xml"),
                Repo.default_ckan_repo.ToString()
                              );
            UpdateModsList();
            ChangeSet = null;
            Conflicts = null;
        }
示例#9
0
        private void PostUpdateRepo(object sender, RunWorkerCompletedEventArgs e)
        {
            var resultPair = e.Result as KeyValuePair <RepoUpdateResult, Dictionary <string, bool> >?;
            RepoUpdateResult?         result     = resultPair?.Key;
            Dictionary <string, bool> oldModules = resultPair?.Value;

            switch (result)
            {
            case RepoUpdateResult.NoChanges:
                AddStatusMessage("Repositories already up to date.");
                HideWaitDialog(true);
                // Load rows if grid empty, otherwise keep current
                if (ModList.Rows.Count < 1)
                {
                    UpdateModsList(ChangeSet);
                }
                break;

            case RepoUpdateResult.Failed:
                AddStatusMessage("Repository update failed!");
                break;

            case RepoUpdateResult.Updated:
            default:
                UpdateModsList(ChangeSet, oldModules);
                AddStatusMessage("Repositories successfully updated.");
                ShowRefreshQuestion();
                HideWaitDialog(true);
                UpgradeNotification();
                break;
            }

            Util.Invoke(this, SwitchEnabledState);
            Util.Invoke(this, RecreateDialogs);
            Util.Invoke(this, ModList.Select);
        }
示例#10
0
        public void LoadProviders(string message, List <CkanModule> modules, NetModuleCache cache)
        {
            Util.Invoke(this, () =>
            {
                ChooseProvidedModsLabel.Text = message;

                ChooseProvidedModsListView.Items.Clear();
                ChooseProvidedModsListView.Items.AddRange(modules
                                                          .Select(module => new ListViewItem(new string[]
                {
                    cache.IsMaybeCachedZip(module)
                            ? string.Format(Properties.Resources.MainChangesetCached, module.name, module.version)
                            : string.Format(Properties.Resources.MainChangesetHostSize, module.name, module.version, module.download.Host ?? "", CkanModule.FmtSize(module.download_size)),
                    module.@abstract
                })
                {
                    Tag     = module,
                    Checked = false
                })
                                                          .ToArray());
                ChooseProvidedModsListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                ChooseProvidedModsContinueButton.Enabled = false;
            });
        }
示例#11
0
 public void UpdateModsList(Boolean repo_updated = false, List <ModChange> mc = null)
 {
     Util.Invoke(this, () => _UpdateModsList(repo_updated, mc ?? new List <ModChange>()));
 }
示例#12
0
 public void MarkModForInstall(string identifier, bool uncheck = false)
 {
     Util.Invoke(this, () => _MarkModForInstall(identifier, uncheck));
 }
示例#13
0
 public void MarkModForUpdate(string identifier)
 {
     Util.Invoke(this, () => _MarkModForUpdate(identifier));
 }
示例#14
0
 private void UpdateFilters(Main control)
 {
     Util.Invoke(control, _UpdateFilters);
 }
示例#15
0
 private void CheckForConsistency()
 {
     Util.Invoke(this, _CheckForConsistency);
 }
示例#16
0
        private void _UpdateModsList(IEnumerable <ModChange> mc, Dictionary <string, bool> old_modules = null)
        {
            log.Info("Updating the mod list");

            ResetProgress();
            tabController.RenameTab("WaitTabPage", Properties.Resources.MainModListWaitTitle);
            ShowWaitDialog(false);
            tabController.SetTabLock(true);
            Util.Invoke(this, SwitchEnabledState);
            ClearLog();

            AddLogMessage(Properties.Resources.MainModListLoadingRegistry);
            KspVersionCriteria versionCriteria = CurrentInstance.VersionCriteria();
            IRegistryQuerier   registry        = RegistryManager.Instance(CurrentInstance).registry;

            AddLogMessage(Properties.Resources.MainModListLoadingInstalled);
            var gui_mods = new HashSet <GUIMod>();

            gui_mods.UnionWith(
                registry.InstalledModules
                .Select(instMod => new GUIMod(instMod, registry, versionCriteria))
                );
            AddLogMessage(Properties.Resources.MainModListLoadingAvailable);
            gui_mods.UnionWith(
                registry.Available(versionCriteria)
                .Select(m => new GUIMod(m, registry, versionCriteria))
                );
            AddLogMessage(Properties.Resources.MainModListLoadingIncompatible);
            gui_mods.UnionWith(
                registry.Incompatible(versionCriteria)
                .Select(m => new GUIMod(m, registry, versionCriteria, true))
                );

            if (mc != null)
            {
                AddLogMessage(Properties.Resources.MainModListRestoringChangeset);
                foreach (ModChange change in mc)
                {
                    // Propagate IsInstallChecked and IsUpgradeChecked to the next generation
                    gui_mods.FirstOrDefault(
                        mod => mod.Identifier == change.Mod.Identifier
                        )?.SetRequestedChange(change.ChangeType);
                }
            }

            AddLogMessage(Properties.Resources.MainModListPreservingNew);
            if (old_modules != null)
            {
                foreach (GUIMod gm in gui_mods)
                {
                    bool oldIncompat;
                    if (old_modules.TryGetValue(gm.Identifier, out oldIncompat))
                    {
                        // Found it; check if newly compatible
                        if (!gm.IsIncompatible && oldIncompat)
                        {
                            gm.IsNew = true;
                        }
                    }
                    else
                    {
                        // Newly indexed, show regardless of compatibility
                        gm.IsNew = true;
                    }
                }
            }
            else
            {
                // Copy the new mod flag from the old list.
                var old_new_mods = new HashSet <GUIMod>(
                    mainModList.Modules.Where(m => m.IsNew));
                foreach (var gui_mod in gui_mods.Where(m => old_new_mods.Contains(m)))
                {
                    gui_mod.IsNew = true;
                }
            }

            AddLogMessage(Properties.Resources.MainModListPopulatingList);
            // Update our mod listing
            mainModList.ConstructModList(gui_mods.ToList(), mc, configuration.HideEpochs, configuration.HideV);
            mainModList.Modules = new ReadOnlyCollection <GUIMod>(
                mainModList.full_list_of_mod_rows.Values.Select(row => row.Tag as GUIMod).ToList());

            AddLogMessage(Properties.Resources.MainModListUpdatingFilters);

            var has_any_updates      = gui_mods.Any(mod => mod.HasUpdate);
            var has_any_installed    = gui_mods.Any(mod => mod.IsInstalled);
            var has_any_replacements = gui_mods.Any(mod => mod.IsInstalled && mod.HasReplacement);

            //TODO Consider using smart enumeration pattern so stuff like this is easier
            Util.Invoke(menuStrip2, () =>
            {
                FilterToolButton.DropDownItems[0].Text = String.Format(Properties.Resources.MainModListCompatible,
                                                                       mainModList.CountModsByFilter(GUIModFilter.Compatible));
                FilterToolButton.DropDownItems[1].Text = String.Format(Properties.Resources.MainModListInstalled,
                                                                       mainModList.CountModsByFilter(GUIModFilter.Installed));
                FilterToolButton.DropDownItems[2].Text = String.Format(Properties.Resources.MainModListUpgradeable,
                                                                       mainModList.CountModsByFilter(GUIModFilter.InstalledUpdateAvailable));
                FilterToolButton.DropDownItems[3].Text = String.Format(Properties.Resources.MainModListReplaceable,
                                                                       mainModList.CountModsByFilter(GUIModFilter.Replaceable));
                FilterToolButton.DropDownItems[4].Text = String.Format(Properties.Resources.MainModListCached,
                                                                       mainModList.CountModsByFilter(GUIModFilter.Cached));
                FilterToolButton.DropDownItems[5].Text = String.Format(Properties.Resources.MainModListNewlyCompatible,
                                                                       mainModList.CountModsByFilter(GUIModFilter.NewInRepository));
                FilterToolButton.DropDownItems[6].Text = String.Format(Properties.Resources.MainModListNotInstalled,
                                                                       mainModList.CountModsByFilter(GUIModFilter.NotInstalled));
                FilterToolButton.DropDownItems[7].Text = String.Format(Properties.Resources.MainModListIncompatible,
                                                                       mainModList.CountModsByFilter(GUIModFilter.Incompatible));
                FilterToolButton.DropDownItems[8].Text = String.Format(Properties.Resources.MainModListAll,
                                                                       mainModList.CountModsByFilter(GUIModFilter.All));

                UpdateAllToolButton.Enabled = has_any_updates;
            });

            UpdateFilters(this);

            // Hide update and replacement columns if not needed.
            // Write it to the configuration, else they are hidden agian after a filter change.
            // After the update / replacement, they are hidden again.
            Util.Invoke(ModList, () =>
            {
                ModList.Columns["UpdateCol"].Visible     = has_any_updates;
                ModList.Columns["AutoInstalled"].Visible = has_any_installed && !configuration.HiddenColumnNames.Contains("AutoInstalled");
                ModList.Columns["ReplaceCol"].Visible    = has_any_replacements;
            });

            AddLogMessage(Properties.Resources.MainModListUpdatingTray);
            UpdateTrayInfo();

            HideWaitDialog(true);
            tabController.HideTab("WaitTabPage");
            tabController.SetTabLock(false);
            Util.Invoke(this, SwitchEnabledState);
            Util.Invoke(this, () => Main.Instance.ModList.Focus());
        }
示例#17
0
 private void UpdateModsList(Boolean repo_updated = false)
 {
     Util.Invoke(this, () => _UpdateModsList(repo_updated));
 }
示例#18
0
文件: Main.cs 项目: mioackerman/CKAN
        /// <summary>
        /// React to switching to a new game instance
        /// </summary>
        /// <param name="allowRepoUpdate">true if a repo update is allowed if needed (e.g. on initial load), false otherwise</param>
        private void CurrentInstanceUpdated(bool allowRepoUpdate)
        {
            CurrentInstance.Scan();
            Util.Invoke(this, () =>
            {
                Text = $"CKAN {Meta.GetVersion()} - {CurrentInstance.game.ShortName} {CurrentInstance.Version()}    --    {CurrentInstance.GameDir().Replace('/', Path.DirectorySeparatorChar)}";
                StatusInstanceLabel.Text = string.Format(
                    Properties.Resources.StatusInstanceLabelText,
                    CurrentInstance.Name,
                    CurrentInstance.game.ShortName,
                    CurrentInstance.Version()?.ToString()
                    );
            });

            configuration = GUIConfiguration.LoadOrCreateConfiguration(
                Path.Combine(CurrentInstance.CkanDir(), "GUIConfig.xml")
                );

            if (CurrentInstance.CompatibleVersionsAreFromDifferentGameVersion)
            {
                new CompatibleGameVersionsDialog(CurrentInstance, !actuallyVisible)
                .ShowDialog();
            }

            (RegistryManager.Instance(CurrentInstance).registry as Registry)
            ?.BuildTagIndex(ManageMods.mainModList.ModuleTags);

            bool repoUpdateNeeded = configuration.RefreshOnStartup ||
                                    !RegistryManager.Instance(CurrentInstance).registry.HasAnyAvailable();

            if (allowRepoUpdate)
            {
                // If not allowing, don't do anything
                if (repoUpdateNeeded)
                {
                    // Update the filters after UpdateRepo() completed.
                    // Since this happens with a backgroundworker, Filter() is added as callback for RunWorkerCompleted.
                    // Remove it again after it ran, else it stays there and is added again and again.
                    void filterUpdate(object sender, RunWorkerCompletedEventArgs e)
                    {
                        ManageMods.Filter(
                            (GUIModFilter)configuration.ActiveFilter,
                            ManageMods.mainModList.ModuleTags.Tags.GetOrDefault(configuration.TagFilter),
                            ManageMods.mainModList.ModuleLabels.LabelsFor(CurrentInstance.Name)
                            .FirstOrDefault(l => l.Name == configuration.CustomLabelFilter)
                            );
                        m_UpdateRepoWorker.RunWorkerCompleted -= filterUpdate;
                    }

                    m_UpdateRepoWorker.RunWorkerCompleted += filterUpdate;

                    ManageMods.ModGrid.Rows.Clear();
                    UpdateRepo();
                }
                else
                {
                    ManageMods.UpdateModsList();
                    ManageMods.Filter(
                        (GUIModFilter)configuration.ActiveFilter,
                        ManageMods.mainModList.ModuleTags.Tags.GetOrDefault(configuration.TagFilter),
                        ManageMods.mainModList.ModuleLabels.LabelsFor(CurrentInstance.Name)
                        .FirstOrDefault(l => l.Name == configuration.CustomLabelFilter)
                        );
                }
            }
            ManageMods.InstanceUpdated(CurrentInstance);
        }
示例#19
0
 public void AddLogMessage(string message)
 {
     Util.Invoke(LogTextBox, () => LogTextBox.AppendText(message + "\r\n"));
 }
示例#20
0
 private void UpdateModDependencyGraph(CkanModule module)
 {
     Util.Invoke(DependsGraphTree, () => _UpdateModDependencyGraph(module));
 }
示例#21
0
 public void PostModCaching(object sender, RunWorkerCompletedEventArgs e)
 {
     Util.Invoke(this, () => _PostModCaching((CkanModule)e.Result));
 }
示例#22
0
        private void PostInstallMods(object sender, RunWorkerCompletedEventArgs e)
        {
            tabController.SetTabLock(false);

            if (e.Error != null)
            {
                switch (e.Error)
                {
                case DependencyNotSatisfiedKraken exc:
                    currentUser.RaiseMessage(Properties.Resources.MainInstallDepNotSatisfied, exc.parent, exc.module);
                    break;

                case ModuleNotFoundKraken exc:
                    currentUser.RaiseMessage(Properties.Resources.MainInstallNotFound, exc.module);
                    break;

                case BadMetadataKraken exc:
                    currentUser.RaiseMessage(Properties.Resources.MainInstallBadMetadata, exc.module, exc.Message);
                    break;

                case FileExistsKraken exc:
                    if (exc.owningModule != null)
                    {
                        currentUser.RaiseMessage(
                            Properties.Resources.MainInstallFileExists,
                            exc.filename, exc.installingModule, exc.owningModule,
                            Meta.GetVersion()
                            );
                    }
                    else
                    {
                        currentUser.RaiseMessage(
                            Properties.Resources.MainInstallUnownedFileExists,
                            exc.installingModule, exc.filename
                            );
                    }
                    currentUser.RaiseMessage(Properties.Resources.MainInstallGameDataReverted);
                    break;

                case InconsistentKraken exc:
                    currentUser.RaiseMessage(exc.InconsistenciesPretty);
                    break;

                case CancelledActionKraken exc:
                    currentUser.RaiseMessage(exc.Message);
                    installCanceled = true;
                    break;

                case MissingCertificateKraken exc:
                    currentUser.RaiseMessage(exc.ToString());
                    break;

                case DownloadThrottledKraken exc:
                    string msg = exc.ToString();
                    currentUser.RaiseMessage(msg);
                    if (YesNoDialog(string.Format(Properties.Resources.MainInstallOpenSettingsPrompt, msg),
                                    Properties.Resources.MainInstallOpenSettings,
                                    Properties.Resources.MainInstallNo))
                    {
                        // Launch the URL describing this host's throttling practices, if any
                        if (exc.infoUrl != null)
                        {
                            Utilities.ProcessStartURL(exc.infoUrl.ToString());
                        }
                        // Now pretend they clicked the menu option for the settings
                        Enabled = false;
                        new SettingsDialog(currentUser).ShowDialog();
                        Enabled = true;
                    }
                    break;

                case ModuleDownloadErrorsKraken exc:
                    currentUser.RaiseMessage(exc.ToString());
                    currentUser.RaiseError(exc.ToString());
                    break;

                case DirectoryNotFoundKraken exc:
                    currentUser.RaiseMessage("\r\n{0}", exc.Message);
                    break;

                case ModuleIsDLCKraken exc:
                    string dlcMsg = string.Format(Properties.Resources.MainInstallCantInstallDLC, exc.module.name);
                    currentUser.RaiseMessage(dlcMsg);
                    currentUser.RaiseError(dlcMsg);
                    break;
                }

                FailWaitDialog(
                    Properties.Resources.MainInstallErrorInstalling,
                    Properties.Resources.MainInstallKnownError,
                    Properties.Resources.MainInstallFailed,
                    false
                    );
            }
            else
            {
                // The Result property throws if InstallMods threw (!!!)
                KeyValuePair <bool, ModChanges> result = (KeyValuePair <bool, ModChanges>)e.Result;
                if (!installCanceled)
                {
                    // Rebuilds the list of GUIMods
                    ManageMods.UpdateModsList(null);

                    if (modChangedCallback != null)
                    {
                        foreach (var mod in result.Value)
                        {
                            modChangedCallback(mod.Mod, mod.ChangeType);
                        }
                    }

                    // install successful
                    AddStatusMessage(Properties.Resources.MainInstallSuccess);
                    HideWaitDialog(true);
                }
                else
                {
                    // User cancelled the installation
                    if (result.Key)
                    {
                        FailWaitDialog(
                            Properties.Resources.MainInstallCancelTooLate,
                            Properties.Resources.MainInstallCancelAfterInstall,
                            Properties.Resources.MainInstallProcessComplete,
                            true
                            );
                    }
                    else
                    {
                        FailWaitDialog(
                            Properties.Resources.MainInstallProcessCanceled,
                            Properties.Resources.MainInstallCanceledManually,
                            Properties.Resources.MainInstallInstallCanceled,
                            false
                            );
                    }
                }
            }

            Util.Invoke(this, () => Enabled = true);
            Util.Invoke(menuStrip1, () => menuStrip1.Enabled = true);
        }
示例#23
0
        /// <summary>
        /// Shows the selection dialog.
        /// </summary>
        /// <returns>The selected index, -1 if canceled.</returns>
        /// <param name="message">Message.</param>
        /// <param name="args">Array of items to select from.</param>
        public int ShowSelectionDialog(string message, params object[] args)
        {
            int defaultSelection = -1;
            int return_cancel    = -1;

            // Validate input.
            if (String.IsNullOrWhiteSpace(message))
            {
                throw new Kraken("Passed message string must be non-empty.");
            }

            if (args.Length == 0)
            {
                throw new Kraken("Passed list of selection candidates must be non-empty.");
            }

            // Hide the default button unless we have a default option
            Util.Invoke(DefaultButton, DefaultButton.Hide);
            // Clear the item list.
            Util.Invoke(OptionsList, OptionsList.Items.Clear);

            // Check if we have a default option.
            if (args[0] is int)
            {
                // Check that the default selection makes sense.
                defaultSelection = (int)args[0];

                if (defaultSelection < 0 || defaultSelection > args.Length - 1)
                {
                    throw new Kraken("Passed default arguments is out of range of the selection candidates.");
                }

                // Extract the relevant arguments.
                object[] newArgs = new object[args.Length - 1];

                for (int i = 1; i < args.Length; i++)
                {
                    newArgs[i - 1] = args[i];
                }

                args = newArgs;

                // Show the defaultButton.
                Util.Invoke(DefaultButton, DefaultButton.Show);
            }

            // Further data validation.
            foreach (object argument in args)
            {
                if (String.IsNullOrWhiteSpace(argument.ToString()))
                {
                    throw new Kraken("Candidate may not be empty.");
                }
            }

            // Add all items to the OptionsList.
            for (int i = 0; i < args.Length; i++)
            {
                if (defaultSelection == i)
                {
                    Util.Invoke(OptionsList, () => OptionsList.Items.Add(String.Concat(args[i].ToString(), "  -- Default")));
                }
                else
                {
                    Util.Invoke(OptionsList, () => OptionsList.Items.Add(args[i].ToString()));
                }
            }

            // Write the message to the label.
            Util.Invoke(MessageLabel, () => MessageLabel.Text = message);

            // Now show the dialog and get the return values.
            DialogResult result = ShowDialog();

            if (result == DialogResult.Yes)
            {
                // If pressed Defaultbutton
                return(defaultSelection);
            }
            else if (result == DialogResult.Cancel)
            {
                // If pressed CancelButton
                return(return_cancel);
            }
            else
            {
                return(currentSelected);
            }
        }
示例#24
0
 public void HideYesNoDialog()
 {
     Util.Invoke(this, Close);
 }
示例#25
0
        // this probably needs to be refactored
        private void InstallMods(object sender, DoWorkEventArgs e)
        {
            installCanceled = false;
            Wait.ClearLog();

            var opts = (KeyValuePair <ModChanges, RelationshipResolverOptions>)e.Argument;

            RegistryManager registry_manager = RegistryManager.Instance(manager.CurrentInstance);
            Registry        registry         = registry_manager.registry;
            ModuleInstaller installer        = ModuleInstaller.GetInstance(CurrentInstance, Manager.Cache, currentUser);

            // Avoid accumulating multiple event handlers
            installer.onReportModInstalled -= OnModInstalled;
            installer.onReportModInstalled += OnModInstalled;
            // setup progress callback

            // this will be the final list of mods we want to install
            HashSet <CkanModule> toInstall = new HashSet <CkanModule>();
            var toUninstall = new HashSet <string>();
            var toUpgrade   = new HashSet <string>();

            // First compose sets of what the user wants installed, upgraded, and removed.
            foreach (ModChange change in opts.Key)
            {
                switch (change.ChangeType)
                {
                case GUIModChangeType.Remove:
                    toUninstall.Add(change.Mod.identifier);
                    break;

                case GUIModChangeType.Update:
                    toUpgrade.Add(change.Mod.identifier);
                    break;

                case GUIModChangeType.Install:
                    toInstall.Add(change.Mod);
                    break;

                case GUIModChangeType.Replace:
                    ModuleReplacement repl = registry.GetReplacement(change.Mod, CurrentInstance.VersionCriteria());
                    if (repl != null)
                    {
                        toUninstall.Add(repl.ToReplace.identifier);
                        toInstall.Add(repl.ReplaceWith);
                    }
                    break;
                }
            }

            // Prompt for recommendations and suggestions, if any
            if (installer.FindRecommendations(
                    opts.Key.Where(ch => ch.ChangeType == GUIModChangeType.Install)
                    .Select(ch => ch.Mod)
                    .ToHashSet(),
                    toInstall,
                    registry,
                    out Dictionary <CkanModule, Tuple <bool, List <string> > > recommendations,
                    out Dictionary <CkanModule, List <string> > suggestions,
                    out Dictionary <CkanModule, HashSet <string> > supporters
                    ))
            {
                tabController.ShowTab("ChooseRecommendedModsTabPage", 3);
                ChooseRecommendedMods.LoadRecommendations(
                    registry, CurrentInstance.VersionCriteria(),
                    Manager.Cache, recommendations, suggestions, supporters);
                tabController.SetTabLock(true);
                var result = ChooseRecommendedMods.Wait();
                if (result == null)
                {
                    installCanceled = true;
                }
                else
                {
                    toInstall.UnionWith(result);
                }
                tabController.SetTabLock(false);
                tabController.HideTab("ChooseRecommendedModsTabPage");
            }

            if (installCanceled)
            {
                tabController.ShowTab("ManageModsTabPage");
                e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                return;
            }

            // Now let's make all our changes.
            Util.Invoke(this, () =>
            {
                // Need to be on the GUI thread to get the translated string
                tabController.RenameTab("WaitTabPage", Properties.Resources.MainInstallWaitTitle);
            });
            ShowWaitDialog();
            tabController.SetTabLock(true);

            IDownloader downloader = new NetAsyncModulesDownloader(currentUser, Manager.Cache);

            downloader.Progress    += Wait.SetModuleProgress;
            downloader.AllComplete += Wait.DownloadsComplete;
            cancelCallback          = () =>
            {
                downloader.CancelDownload();
                installCanceled = true;
            };

            HashSet <string> possibleConfigOnlyDirs = null;

            // checks if all actions were successfull
            bool processSuccessful       = false;
            bool resolvedAllProvidedMods = false;

            // uninstall/installs/upgrades until every list is empty
            // if the queue is NOT empty, resolvedAllProvidedMods is set to false until the action is done
            while (!resolvedAllProvidedMods)
            {
                try
                {
                    e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                    if (toUninstall.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.UninstallList(toUninstall, ref possibleConfigOnlyDirs, registry_manager, false, toInstall);
                            processSuccessful = true;
                        }
                    }
                    if (toUpgrade.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.Upgrade(toUpgrade, downloader, ref possibleConfigOnlyDirs, registry_manager);
                            processSuccessful = true;
                        }
                    }
                    if (toInstall.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.InstallList(toInstall, opts.Value, registry_manager, ref possibleConfigOnlyDirs, downloader, false);
                            processSuccessful = true;
                        }
                    }

                    HandlePossibleConfigOnlyDirs(registry, possibleConfigOnlyDirs);

                    e.Result = new KeyValuePair <bool, ModChanges>(processSuccessful, opts.Key);
                    if (installCanceled)
                    {
                        return;
                    }
                    resolvedAllProvidedMods = true;
                }
                catch (TooManyModsProvideKraken k)
                {
                    // Prompt user to choose which mod to use
                    tabController.ShowTab("ChooseProvidedModsTabPage", 3);
                    ChooseProvidedMods.LoadProviders(k.requested, k.modules, Manager.Cache);
                    tabController.SetTabLock(true);
                    CkanModule chosen = ChooseProvidedMods.Wait();
                    // Close the selection prompt
                    tabController.SetTabLock(false);
                    tabController.HideTab("ChooseProvidedModsTabPage");
                    if (chosen != null)
                    {
                        // User picked a mod, queue it up for installation
                        toInstall.Add(chosen);
                        // DON'T return so we can loop around and try the above InstallList call again
                        tabController.ShowTab("WaitTabPage");
                    }
                    else
                    {
                        // User cancelled, get out
                        tabController.ShowTab("ManageModsTabPage");
                        e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                        return;
                    }
                }
            }
        }
示例#26
0
 public void HideErrorDialog()
 {
     Util.Invoke(this, () => Close());
 }
示例#27
0
        // this probably needs to be refactored
        private void InstallMods(object sender, DoWorkEventArgs e)
        {
            installCanceled = false;
            ClearLog();

            var opts = (KeyValuePair <ModChanges, RelationshipResolverOptions>)e.Argument;

            IRegistryQuerier registry  = RegistryManager.Instance(manager.CurrentInstance).registry;
            ModuleInstaller  installer = ModuleInstaller.GetInstance(CurrentInstance, Manager.Cache, GUI.user);

            // Avoid accumulating multiple event handlers
            installer.onReportModInstalled -= OnModInstalled;
            installer.onReportModInstalled += OnModInstalled;
            // setup progress callback

            // this will be the final list of mods we want to install
            HashSet <CkanModule> toInstall = new HashSet <CkanModule>();
            var toUninstall = new HashSet <string>();
            var toUpgrade   = new HashSet <string>();

            // First compose sets of what the user wants installed, upgraded, and removed.
            foreach (ModChange change in opts.Key)
            {
                switch (change.ChangeType)
                {
                case GUIModChangeType.Remove:
                    toUninstall.Add(change.Mod.Identifier);
                    break;

                case GUIModChangeType.Update:
                    toUpgrade.Add(change.Mod.Identifier);
                    break;

                case GUIModChangeType.Install:
                    toInstall.Add(change.Mod.ToModule());
                    break;

                case GUIModChangeType.Replace:
                    ModuleReplacement repl = registry.GetReplacement(change.Mod.ToModule(), CurrentInstance.VersionCriteria());
                    if (repl != null)
                    {
                        toUninstall.Add(repl.ToReplace.identifier);
                        toInstall.Add(repl.ReplaceWith);
                    }
                    break;
                }
            }

            // Prompt for recommendations and suggestions, if any
            var recRows = getRecSugRows(
                opts.Key.Where(ch => ch.ChangeType == GUIModChangeType.Install)
                .Select(ch => ch.Mod.ToModule()),
                registry, toInstall
                );

            if (recRows.Any())
            {
                ShowRecSugDialog(recRows, toInstall);
            }

            tabController.HideTab("ChooseRecommendedModsTabPage");

            if (installCanceled)
            {
                tabController.ShowTab("ManageModsTabPage");
                e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                return;
            }

            // Now let's make all our changes.
            tabController.RenameTab("WaitTabPage", "Status log");
            ShowWaitDialog();
            tabController.SetTabLock(true);

            IDownloader downloader = new NetAsyncModulesDownloader(GUI.user);

            cancelCallback = () =>
            {
                downloader.CancelDownload();
                installCanceled = true;
            };

            // checks if all actions were successfull
            bool processSuccessful       = false;
            bool resolvedAllProvidedMods = false;

            // uninstall/installs/upgrades until every list is empty
            // if the queue is NOT empty, resolvedAllProvidedMods is set to false until the action is done
            while (!resolvedAllProvidedMods)
            {
                try
                {
                    e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                    if (toUninstall.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.UninstallList(toUninstall, false, toInstall.Select(m => m.identifier));
                            processSuccessful = true;
                        }
                    }
                    if (toUpgrade.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.Upgrade(toUpgrade, downloader);
                            processSuccessful = true;
                        }
                    }
                    if (toInstall.Count > 0)
                    {
                        processSuccessful = false;
                        if (!installCanceled)
                        {
                            installer.InstallList(toInstall, opts.Value, downloader, false);
                            processSuccessful = true;
                        }
                    }
                    e.Result = new KeyValuePair <bool, ModChanges>(processSuccessful, opts.Key);
                    if (installCanceled)
                    {
                        return;
                    }
                    resolvedAllProvidedMods = true;
                }
                catch (TooManyModsProvideKraken k)
                {
                    // Prompt user to choose which mod to use
                    CkanModule chosen = TooManyModsProvideCore(k).Result;
                    // Close the selection prompt
                    Util.Invoke(this, () =>
                    {
                        tabController.ShowTab("WaitTabPage");
                        tabController.HideTab("ChooseProvidedModsTabPage");
                    });
                    if (chosen != null)
                    {
                        // User picked a mod, queue it up for installation
                        toInstall.Add(chosen);
                        // DON'T return so we can loop around and try the above InstallList call again
                    }
                    else
                    {
                        // User cancelled, get out
                        tabController.ShowTab("ManageModsTabPage");
                        e.Result = new KeyValuePair <bool, ModChanges>(false, opts.Key);
                        return;
                    }
                }
                catch (DependencyNotSatisfiedKraken ex)
                {
                    GUI.user.RaiseMessage(
                        "{0} requires {1} but it is not listed in the index, or not available for your version of KSP.",
                        ex.parent, ex.module);
                    return;
                }
                catch (ModuleNotFoundKraken ex)
                {
                    GUI.user.RaiseMessage(
                        "Module {0} required but it is not listed in the index, or not available for your version of KSP.",
                        ex.module);
                    return;
                }
                catch (BadMetadataKraken ex)
                {
                    GUI.user.RaiseMessage("Bad metadata detected for module {0}: {1}", ex.module, ex.Message);
                    return;
                }
                catch (FileExistsKraken ex)
                {
                    if (ex.owningModule != null)
                    {
                        GUI.user.RaiseMessage(
                            "\r\nOh no! We tried to overwrite a file owned by another mod!\r\n" +
                            "Please try a `ckan update` and try again.\r\n\r\n" +
                            "If this problem re-occurs, then it maybe a packaging bug.\r\n" +
                            "Please report it at:\r\n\r\n" +
                            "https://github.com/KSP-CKAN/NetKAN/issues/new\r\n\r\n" +
                            "Please including the following information in your report:\r\n\r\n" +
                            "File           : {0}\r\n" +
                            "Installing Mod : {1}\r\n" +
                            "Owning Mod     : {2}\r\n" +
                            "CKAN Version   : {3}\r\n",
                            ex.filename, ex.installingModule, ex.owningModule,
                            Meta.GetVersion()
                            );
                    }
                    else
                    {
                        GUI.user.RaiseMessage(
                            "\r\n\r\nOh no!\r\n\r\n" +
                            "It looks like you're trying to install a mod which is already installed,\r\n" +
                            "or which conflicts with another mod which is already installed.\r\n\r\n" +
                            "As a safety feature, the CKAN will *never* overwrite or alter a file\r\n" +
                            "that it did not install itself.\r\n\r\n" +
                            "If you wish to install {0} via the CKAN,\r\n" +
                            "then please manually uninstall the mod which owns:\r\n\r\n" +
                            "{1}\r\n\r\n" + "and try again.\r\n",
                            ex.installingModule, ex.filename
                            );
                    }

                    GUI.user.RaiseMessage("Your GameData has been returned to its original state.\r\n");
                    return;
                }
                catch (InconsistentKraken ex)
                {
                    // The prettiest Kraken formats itself for us.
                    GUI.user.RaiseMessage(ex.InconsistenciesPretty);
                    return;
                }
                catch (CancelledActionKraken)
                {
                    return;
                }
                catch (MissingCertificateKraken kraken)
                {
                    // Another very pretty kraken.
                    GUI.user.RaiseMessage(kraken.ToString());
                    return;
                }
                catch (DownloadThrottledKraken kraken)
                {
                    string msg = kraken.ToString();
                    GUI.user.RaiseMessage(msg);
                    if (YesNoDialog($"{msg}\r\n\r\nOpen settings now?", "Open Settings", "No"))
                    {
                        // Launch the URL describing this host's throttling practices, if any
                        if (kraken.infoUrl != null)
                        {
                            Process.Start(new ProcessStartInfo()
                            {
                                UseShellExecute = true,
                                FileName        = kraken.infoUrl.ToString()
                            });
                        }
                        // Now pretend they clicked the menu option for the settings
                        Enabled = false;
                        settingsDialog.ShowDialog();
                        Enabled = true;
                    }
                    return;
                }
                catch (ModuleDownloadErrorsKraken kraken)
                {
                    GUI.user.RaiseMessage(kraken.ToString());
                    GUI.user.RaiseError(kraken.ToString());
                    return;
                }
                catch (DirectoryNotFoundKraken kraken)
                {
                    GUI.user.RaiseMessage("\r\n{0}", kraken.Message);
                    return;
                }
                catch (DllNotFoundException)
                {
                    if (GUI.user.RaiseYesNoDialog("libcurl installation not found. Open wiki page for help?"))
                    {
                        Process.Start(new ProcessStartInfo()
                        {
                            UseShellExecute = true,
                            FileName        = "https://github.com/KSP-CKAN/CKAN/wiki/libcurl"
                        });
                    }
                    throw;
                }
            }
        }
示例#28
0
 public void SetDescription(string message)
 {
     Util.Invoke(MessageTextBox, () => MessageTextBox.Text = "(" + message + ")");
 }
示例#29
0
 private void UpdateModContentsTree(CkanModule module)
 {
     Util.Invoke(ContentsPreviewTree, () => _UpdateModContentsTree(module));
 }
示例#30
0
 public void ClearLog()
 {
     Util.Invoke(LogTextBox, () => LogTextBox.Text = "");
 }