Esempio n. 1
0
        /// <summary>
        /// Event handler for mod toggle button changed
        /// </summary>
        private async void modToggleButton_Click(object sender, RoutedEventArgs e)
        {
            var gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
            var modding       = new Modding(gameDirectory);

            if ((ModListTreeView.SelectedItem as Category).ParentCategory.Name.Equals("ModPacks"))
            {
                var selectedItem = (ModListTreeView.SelectedItem as Category);

                if ((DataContext as ModListViewModel).ModToggleText == FFXIV_TexTools.Resources.UIStrings.Enable)
                {
                    await modding.ToggleModPackStatus(selectedItem.Name, true);

                    (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Disable;
                }
                else
                {
                    await modding.ToggleModPackStatus(selectedItem.Name, false);

                    (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Enable;
                }

                (DataContext as ModListViewModel).UpdateInfoGrid(selectedItem);
            }
            else
            {
                foreach (ModListViewModel.ModListModel selectedModItem in ModItemList.SelectedItems)
                {
                    // If mod offset is equal to original offset there is no point in toggling as is the case for matadd textures
                    if (selectedModItem.ModItem.data.modOffset == selectedModItem.ModItem.data.originalOffset)
                    {
                        continue;
                    }
                    if (selectedModItem.ModItem.enabled)
                    {
                        await modding.ToggleModStatus(selectedModItem.ModItem.fullPath, false);

                        (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Enable;
                        selectedModItem.ActiveBorder    = Brushes.Red;
                        selectedModItem.Active          = Brushes.Gray;
                        selectedModItem.ActiveOpacity   = 0.5f;
                        selectedModItem.ModItem.enabled = false;
                    }
                    else
                    {
                        await modding.ToggleModStatus(selectedModItem.ModItem.fullPath, true);

                        (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Disable;
                        selectedModItem.ActiveBorder    = Brushes.Green;
                        selectedModItem.Active          = Brushes.Transparent;
                        selectedModItem.ActiveOpacity   = 1;
                        selectedModItem.ModItem.enabled = true;
                    }
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Event handler for mod toggle button changed
        /// </summary>
        private void modToggleButton_Click(object sender, RoutedEventArgs e)
        {
            var gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
            var modding       = new Modding(gameDirectory);

            if ((ModListTreeView.SelectedItem as Category).ParentCategory.Name.Equals("ModPacks"))
            {
                var selectedItem = (ModListTreeView.SelectedItem as Category);
                if ((DataContext as ModListViewModel).ModToggleText == "Enable")
                {
                    modding.ToggleModPackStatus(selectedItem.Name, true);
                    (DataContext as ModListViewModel).ModToggleText = "Disable";
                }
                else
                {
                    modding.ToggleModPackStatus(selectedItem.Name, false);
                    (DataContext as ModListViewModel).ModToggleText = "Enable";
                }

                (DataContext as ModListViewModel).UpdateInfoGrid(selectedItem);
            }
            else
            {
                foreach (ModListViewModel.ModListModel selectedModItem in ModItemList.SelectedItems)
                {
                    if (selectedModItem.ModItem.enabled)
                    {
                        modding.ToggleModStatus(selectedModItem.ModItem.fullPath, false);
                        (DataContext as ModListViewModel).ModToggleText = "Enable";
                        selectedModItem.ActiveBorder    = Brushes.Red;
                        selectedModItem.Active          = Brushes.Gray;
                        selectedModItem.ActiveOpacity   = 0.5f;
                        selectedModItem.ModItem.enabled = false;
                    }
                    else
                    {
                        modding.ToggleModStatus(selectedModItem.ModItem.fullPath, true);
                        (DataContext as ModListViewModel).ModToggleText = "Disable";
                        selectedModItem.ActiveBorder    = Brushes.Green;
                        selectedModItem.Active          = Brushes.Transparent;
                        selectedModItem.ActiveOpacity   = 1;
                        selectedModItem.ModItem.enabled = true;
                    }
                }
            }
        }
Esempio n. 3
0
        private async void ToggleButton_Click(object sender, RoutedEventArgs e)
        {
            var _modding = new Modding(XivCache.GameInfo.GameDirectory);
            var path     = _root.Info.GetRootFile();
            var mod      = await _modding.TryGetModEntry(path);

            if (mod == null)
            {
                return;
            }
            var enabled = mod.enabled;

            await MainWindow.GetMainWindow().LockUi("Updating Metadata");

            try
            {
                if (enabled)
                {
                    await _modding.ToggleModStatus(path, false);

                    ToggleButton.Content = "Enable";
                }
                else
                {
                    await _modding.ToggleModStatus(path, true);

                    ToggleButton.Content = "Disable";
                }
            }
            catch (Exception ex)
            {
                FlexibleMessageBox.Show("Unable to toggle mod status.\n\nError: " + ex.Message, "Mod Toggle Error", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
            }
            finally
            {
                await MainWindow.GetMainWindow().UnlockUi();

                var mw = MainWindow.GetMainWindow();
                mw.ReloadItem();
            }
        }
        public async Task DisableMod()
        {
            _view.SaveButton.IsEnabled    = false;
            _view.CancelButton.IsEnabled  = false;
            _view.DisableButton.IsEnabled = false;
            _view.DisableButton.Content   = UIStrings.Working_Ellipsis;
            var files = new List <string>();

            // If we're disabling from the Edit Multi menu, diable all variant versions as well.
            if (_mode == MaterialEditorMode.EditMulti)
            {
                var sameModelItems = await _item.GetSharedModelItems();

                var itemType = ItemType.GetPrimaryItemType(_item);
                // Find all the variant materials
                foreach (var item in sameModelItems)
                {
                    var variantPath = await _mtrl.GetMtrlPath(item, _material.GetRace(), _material.GetMaterialIdentifier(), itemType);

                    files.Add(variantPath.Folder + "/" + variantPath.File);
                }
            }
            else
            {
                // Just disabling this one.
                files.Add(_material.MTRLPath);
            }

            files = files.Distinct().ToList();

            foreach (var file in files)
            {
                var modEntry = await _modding.TryGetModEntry(file);

                if (!modEntry.enabled)
                {
                    continue;
                }

                // If the file is a custom addition, and not a modification.
                if (modEntry.source != XivStrings.TexTools)
                {
                    await _modding.DeleteMod(file);
                }
                else
                {
                    await _modding.ToggleModStatus(file, false);
                }
            }
            _view.Close(false);
        }
Esempio n. 5
0
        /// <summary>
        /// Disables the .rgsp file for this race, if it exists, and restores the .cmp file for the race back to default.
        /// </summary>
        /// <param name="race"></param>
        /// <param name="gender"></param>
        /// <returns></returns>
        public static async Task DisableRgspMod(XivSubRace race, XivGender gender)
        {
            var path     = GetRgspPath(race, gender);
            var _modding = new Modding(XivCache.GameInfo.GameDirectory);


            var modlist = await _modding.GetModListAsync();

            var mod = modlist.Mods.FirstOrDefault(x => x.fullPath == path);

            if (mod != null && mod.enabled)
            {
                await _modding.ToggleModStatus(path, false);
            }
            else
            {
                var def = await GetScalingParameter(race, gender, true);
                await SetScalingParameter(def);
            }
        }
Esempio n. 6
0
        public async Task DisableMod()
        {
            _view.SaveButton.IsEnabled    = false;
            _view.CancelButton.IsEnabled  = false;
            _view.DisableButton.IsEnabled = false;
            _view.DisableButton.Content   = UIStrings.Working_Ellipsis;
            var files = new HashSet <string>();

            var root = _item.GetRoot();

            if (root == null || !Imc.UsesImc(root))
            {
                // This is the only copy of the material we know how to find.
                files.Add(_material.MTRLPath);
            }
            else
            {
                var imc  = new Imc(XivCache.GameInfo.GameDirectory);
                var info = await imc.GetFullImcInfo(_item);

                var entries      = info.GetAllEntries(root.Info.Slot);
                var materialSets = entries.Select(x => x.MaterialSet).ToHashSet();

                var extract = new Regex("(v[0-9]{4})");
                var rep     = extract.Match(_material.MTRLPath).Groups[1].Value;

                // Remove the material in all of the referenced material sets.
                foreach (var setId in materialSets)
                {
                    var newPath = _material.MTRLPath.Replace(rep, "v" + setId.ToString().PadLeft(4, '0'));
                    files.Add(newPath);
                }
            }

            try
            {
                foreach (var file in files)
                {
                    var modEntry = await _modding.TryGetModEntry(file);

                    if (modEntry == null)
                    {
                        continue;
                    }

                    // If the file is a custom addition, and not a modification.
                    if (modEntry.IsCustomFile())
                    {
                        await _modding.DeleteMod(file);
                    }
                    else
                    {
                        await _modding.ToggleModStatus(file, false);
                    }
                }
            } catch (Exception ex)
            {
                FlexibleMessageBox.Show("Unable to delete Mod.\n\nError: " + ex.Message, "Mod Delete Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            _view.Close(false);
        }
Esempio n. 7
0
        /// <summary>
        /// Event handler for mod toggle button changed
        /// </summary>
        private async void modToggleButton_Click(object sender, RoutedEventArgs e)
        {
            var gameDirectory = new DirectoryInfo(Properties.Settings.Default.FFXIV_Directory);
            var modding       = new Modding(gameDirectory);

            await LockUi("Changing Mod Status", "Please wait...", this);

            try
            {
                if ((ModListTreeView.SelectedItem as Category).ParentCategory.Name.Equals("ModPacks"))
                {
                    var selectedItem = (ModListTreeView.SelectedItem as Category);

                    if ((DataContext as ModListViewModel).ModToggleText == FFXIV_TexTools.Resources.UIStrings.Enable)
                    {
                        try
                        {
                            await modding.ToggleModPackStatus(selectedItem.Name, true);

                            (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Disable;
                        }
                        catch (Exception ex)
                        {
                            FlexibleMessageBox.Show("Unable to fully disable Modpack.\nPlease use Help => Download Index Backups/Help => Start Over\n" + "Error: " + ex.Message, "Mod Disable Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    else
                    {
                        try
                        {
                            await modding.ToggleModPackStatus(selectedItem.Name, false);

                            (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Enable;
                        }
                        catch (Exception ex)
                        {
                            FlexibleMessageBox.Show("Unable to fully enable Modpack.\n\n" + "Error: " + ex.Message, "Mod Enable Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }

                    (DataContext as ModListViewModel).UpdateInfoGrid(selectedItem);
                }
                else
                {
                    var items = ModItemList.SelectedItems;
                    foreach (ModListViewModel.ModListModel selectedModItem in items)
                    {
                        if (selectedModItem.ModItem.enabled)
                        {
                            var success = false;
                            try
                            {
                                success = await modding.ToggleModStatus(selectedModItem.ModItem.fullPath, false);
                            }
                            catch (Exception ex)
                            {
                                FlexibleMessageBox.Show("Unable to disable mod.\nPlease use Help => Download Index Backups/Help => Start Over\n" + "Error: " + ex.Message, "Mod Disable Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                            if (success)
                            {
                                (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Enable;
                                selectedModItem.ActiveBorder    = Brushes.Red;
                                selectedModItem.Active          = Brushes.Gray;
                                selectedModItem.ActiveOpacity   = 0.5f;
                                selectedModItem.ModItem.enabled = false;
                            }
                        }
                        else
                        {
                            var success = false;
                            try
                            {
                                success = await modding.ToggleModStatus(selectedModItem.ModItem.fullPath, true);
                            }
                            catch (Exception ex)
                            {
                                FlexibleMessageBox.Show("Unable to enable mod.\n\n" + "Error: " + ex.Message, "Mod Disable Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                            if (success)
                            {
                                (DataContext as ModListViewModel).ModToggleText = FFXIV_TexTools.Resources.UIStrings.Disable;
                                selectedModItem.ActiveBorder    = Brushes.Green;
                                selectedModItem.Active          = Brushes.Transparent;
                                selectedModItem.ActiveOpacity   = 1;
                                selectedModItem.ModItem.enabled = true;
                            }
                        }
                    }
                }
            }
            finally
            {
                await UnlockUi(this);
            }
        }