public static List <ModProjectData> LoadAll(DOS2DEModuleData Data, bool clearExisting = false)
{
var newMods = LoadModProjects(Data, clearExisting);
LoadManagedProjects(Data, newMods, clearExisting);
LoadSourceControlData(Data, newMods);
return(newMods);
}
public LocaleEditorWindow(DOS2DEModuleData data)
{
ModuleData = data;
Init();
this.WhenActivated((d) =>
{
KeyDown += LocaleEditorWindow_KeyDown;
disposables = d;
KeyActionsGrid = this.FindResource("KeyActionsGrid");
ViewModel.OnViewLoaded(this, ModuleData, disposables);
this.ClipboardUpdateCommand = ViewModel.OnClipboardChangedCommand;
ViewModel.PopoutContentCommand = ReactiveCommand.Create(() => PopoutContentWindow(ViewModel.SelectedEntry), ViewModel.CanExecutePopoutContentCommand).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.SelectedEntryHtmlContent, view => view.EntryContentPreviewHtmlPanel.Text).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.RemoveSelectedMissingEntriesCommand, view => view.ConfirmRemovedEntriesButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.CloseMissingEntriesCommand, view => view.CancelRemovedEntriesButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.CopySimpleMissingEntriesCommand, view => view.CopySimpleMissingEntriesButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.CopyAllMissingEntriesCommand, view => view.CopyAllDataMissingEntriesButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.MissingEntries, view => view.RemovedEntriesListView.ItemsSource).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.MissingEntriesViewVisible, view => view.RemovedEntriesGrid.Visibility).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.SaveCurrentCommand, view => view.SaveButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.SaveAllCommand, view => view.SaveAllButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.AddFileCommand, view => view.AddFileButton.Command).DisposeWith(d);
//this.OneWayBind(this.ViewModel, vm => vm.ImportFileCommand, view => view.ImportFileButton.Command).DisposeWith(d);
CreateButtonBinding("RemoveSelectedMissingEntriesCommand", ConfirmRemovedEntriesButton);
CreateButtonBinding("CloseMissingEntriesCommand", CancelRemovedEntriesButton);
CreateButtonBinding("CopySimpleMissingEntriesCommand", CopySimpleMissingEntriesButton);
CreateButtonBinding("CopyAllMissingEntriesCommand", CopyAllDataMissingEntriesButton);
CreateBinding("MissingEntries", RemovedEntriesListView, ListView.ItemsSourceProperty);
CreateBinding("MissingEntriesViewVisible", RemovedEntriesGrid, Grid.VisibilityProperty);
CreateButtonBinding("SaveCurrentCommand", SaveButton);
CreateButtonBinding("SaveAllCommand", SaveAllButton);
CreateButtonBinding("AddFileCommand", AddFileButton);
CreateButtonBinding("ImportFileCommand", ImportFileButton);
var res = this.TryFindResource("EntryContentPreview");
if (res != null && res is HtmlPanel entryContentPreviewHtmlPanel)
{
CreateBinding("SelectedEntryHtmlContent", entryContentPreviewHtmlPanel, HtmlPanel.TextProperty);
}
Log.Here().Important("Activated LocaleEditorWindow");
});
}
public static bool SaveManagedProjects(DOS2DEModuleData Data)
{
Log.Here().Important("Saving Managed Projects data to {0}", Data.Settings.AddedProjectsFile);
if (Data.ManagedProjectsData != null && Data.ManagedProjectsData.SavedProjects.Count > 0 && Data.Settings != null && FileCommands.IsValidPath(Data.Settings.AddedProjectsFile))
{
//Data.ManagedProjectsData.Projects.Clear();
//Data.ManagedProjectsData.Projects.AddRange(Data.ManagedProjects.Select(m => m.ProjectAppData).ToList());
string json = JsonInterface.SerializeObject(Data.ManagedProjectsData);
return(FileCommands.WriteToFile(Data.Settings.AddedProjectsFile, json));
}
return(false);
}
public static async Task <bool> LoadSourceControlDataAsync(DOS2DEModuleData Data, IEnumerable <ModProjectData> modProjects)
{
try
{
if (Directory.Exists(Data.Settings.GitRootDirectory))
{
int totalSuccess = 0;
var sourceFiles = new List <SourceControlData>();
var folders = Directory.EnumerateDirectories(Data.Settings.GitRootDirectory);
foreach (var folder in folders)
{
var sourceFile = Path.Combine(folder, "SourceControlGenerator.json");
if (File.Exists(sourceFile))
{
sourceFiles.Add(await SourceControlData.FromPathAsync(sourceFile));
}
}
foreach (var project in modProjects)
{
var sourceControlData = sourceFiles.FirstOrDefault(x => x.ProjectUUID == project.UUID || x.ProjectUUID == project.ProjectInfo.UUID);
if (sourceControlData != null)
{
project.GitData = sourceControlData;
project.GitGenerated = true;
var gitDirectory = Path.Combine(Path.GetDirectoryName(sourceControlData.SourceFile), ".git");
if (Directory.Exists(gitDirectory))
{
var lastModifiedDate = File.GetLastWriteTime(gitDirectory);
if (lastModifiedDate != null && project.ModuleInfo.ModifiedDate.Ticks < lastModifiedDate.Ticks)
{
project.ModuleInfo.ModifiedDate = lastModifiedDate;
}
}
totalSuccess += 1;
}
}
return(totalSuccess > 0);
}
}
catch (Exception ex)
{
Log.Here().Error("Error loading source control data:");
Log.Here().Error(ex.ToString());
}
return(false);
}
public static async Task <List <ModProjectData> > LoadAllAsync(DOS2DEModuleData Data, bool clearExisting = false, bool continueOnCaptureContext = true)
{
Log.Here().Activity("Loading all mod projects data.");
var newMods = await LoadModProjectsAsync(Data, clearExisting);
Log.Here().Activity("Loading all managed projects data.");
await LoadManagedProjectsAsync(Data, newMods, clearExisting);
Log.Here().Activity("Loading all source control data.");
await LoadSourceControlDataAsync(Data, newMods);
Log.Here().Activity("Loading complete!");
return(newMods);
}
public DOS2DEProjectsView()
{
InitializeComponent();
_instance = this;
if (DesignerProperties.GetIsInDesignMode(this))
{
ViewModel = new DOS2DEModuleData();
ViewModel.AvailableProjectsVisible = true;
ViewModel.LoadPanelVisibility = Visibility.Collapsed;
}
Init();
}
public static async Task <bool> RefreshAvailableProjects(DOS2DEModuleData Data)
{
//await new SynchronizationContextRemover();
var newMods = await LoadModProjectsAsync(Data, true);
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
Data.ModProjects.AddRange(newMods);
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
Data.ModProjects.AddRange(newMods);
}
await LoadManagedProjectsAsync(Data, newMods, true);
return(true);
}
public static async Task <bool> RefreshManagedProjects(DOS2DEModuleData Data)
{
if (Data.ManagedProjects != null && Data.ManagedProjects.Count > 0)
{
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DEDataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DEDataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity("Reloading DOS2 project data from mods directory at: {0}.", modsPath);
foreach (var project in Data.ManagedProjects)
{
var modData = Data.ModProjects.Items.FirstOrDefault(p => p.ProjectName == project.ProjectName && p.UUID == project.UUID);
if (modData != null)
{
Log.Here().Activity($"Reloading data for project {project.ProjectName}.");
await modData.ReloadDataAsync();
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DEDataDirectory);
}
}
//Reload settings like if a git project actually exists
await LoadSourceControlDataAsync(Data, Data.ModProjects.Items);
}
return(true);
}
public static bool LoadSourceControlData(DOS2DEModuleData Data, IEnumerable <ModProjectData> modProjects)
{
if (Directory.Exists(Data.Settings.GitRootDirectory))
{
int totalSuccess = 0;
var projectFiles = Directory.EnumerateFiles(Data.Settings.GitRootDirectory, DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive, new DirectoryEnumerationFilters
{
InclusionFilter = (f) =>
{
return(f.FileName.Equals("SourceControlGenerator.json", StringComparison.OrdinalIgnoreCase));
}
}).Select(x => SourceControlData.FromPath(x));
foreach (var project in modProjects)
{
var sourceControlData = projectFiles.FirstOrDefault(x => x.ProjectUUID == project.UUID);
if (sourceControlData != null)
{
project.GitData = sourceControlData;
project.GitGenerated = true;
var gitDirectory = Path.Combine(Path.GetDirectoryName(sourceControlData.SourceFile), ".git");
if (Directory.Exists(gitDirectory))
{
var lastModifiedDate = File.GetLastWriteTime(gitDirectory);
if (lastModifiedDate != null && project.ModuleInfo.ModifiedDate.Ticks < lastModifiedDate.Ticks)
{
project.ModuleInfo.ModifiedDate = lastModifiedDate;
}
}
totalSuccess += 1;
}
}
return(totalSuccess > 0);
}
return(false);
}
public static void SetData(DOS2DEModuleData moduleData)
{
MainData = moduleData;
}
public static List <ModProjectData> LoadModProjects(DOS2DEModuleData Data, bool clearExisting = false)
{
if (clearExisting)
{
Data.ModProjects.Clear();
Log.Here().Important("Cleared mod project data.");
}
List <ModProjectData> newItems = new List <ModProjectData>();
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DEDataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DEDataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity("Loading DOS2 projects from mods directory at: {0}", modsPath);
DirectoryEnumerationFilters filters = new DirectoryEnumerationFilters()
{
InclusionFilter = (f) =>
{
return(!IgnoredFolders.Contains(f.FileName));
},
};
var modFolders = Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
if (modFolders != null)
{
foreach (string modFolder in modFolders)
{
var modFolderName = Path.GetFileName(modFolder);
//Log.Here().Activity("Checking project mod folder: {0}", modFolderName);
var metaFilePath = Path.Combine(modFolder, "meta.lsx");
if (File.Exists(metaFilePath))
{
//Log.Here().Activity("Meta file found for project {0}. Reading file.", modFolderName);
ModProjectData modProjectData = new ModProjectData();
modProjectData.LoadAllData(metaFilePath, projectsPath);
//Log.Here().Activity("Finished reading meta files for mod: {0}", modProjectData.ModuleInfo.Name);
if (!clearExisting)
{
var previous = Data.ModProjects.Items.FirstOrDefault(p => p.FolderName == modProjectData.FolderName);
if (previous != null)
{
if (previous.DataIsNewer(modProjectData))
{
previous.UpdateData(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DEDataDirectory);
}
}
return(newItems);
}
public static async Task <Unit> LoadManagedProjectsAsync(DOS2DEModuleData Data, List <ModProjectData> modProjects, bool clearExisting = false)
{
try
{
if (clearExisting)
{
foreach (var mod in Data.ModProjects.Items)
{
mod.IsManaged = false;
}
}
string projectsAppDataPath = DefaultPaths.ModuleAddedProjectsFile(Data);
if (Data.Settings != null && File.Exists(Data.Settings.AddedProjectsFile))
{
projectsAppDataPath = Data.Settings.AddedProjectsFile;
}
if (!String.IsNullOrEmpty(projectsAppDataPath) && File.Exists(projectsAppDataPath))
{
try
{
string contents = await FileCommands.ReadFileAsync(projectsAppDataPath);
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Error
};
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
Data.ManagedProjectsData = JsonConvert.DeserializeObject <ManagedProjectsData>(contents, settings);
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
Data.ManagedProjectsData = JsonConvert.DeserializeObject <ManagedProjectsData>(contents, settings);
}
}
catch (Exception ex)
{
Log.Here().Error("Error deserializing managed projects data at {0}: {1}", projectsAppDataPath, ex.ToString());
}
}
Debug.WriteLine("Loading managed project data");
if (Data.ManagedProjectsData == null)
{
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
Data.ManagedProjectsData = new ManagedProjectsData();
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
Data.ManagedProjectsData = new ManagedProjectsData();
}
}
else
{
if (Data.ManagedProjectsData.SortedProjects != null)
{
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
foreach (var p in Data.ManagedProjectsData.SortedProjects)
{
Data.ManagedProjectsData.SavedProjects.AddOrUpdate(p);
}
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
foreach (var p in Data.ManagedProjectsData.SortedProjects)
{
Data.ManagedProjectsData.SavedProjects.AddOrUpdate(p);
}
}
}
foreach (var m in Data.ManagedProjectsData.SavedProjects.Items)
{
var modData = modProjects.FirstOrDefault(p => p.UUID == m.UUID);
if (modData != null)
{
modData.IsManaged = true;
if (clearExisting)
{
await modData.ReloadDataAsync();
if (!String.IsNullOrWhiteSpace(m.LastBackupUTC))
{
DateTime lastBackup;
var success = DateTime.TryParse(m.LastBackupUTC, out lastBackup);
if (success)
{
//Log.Here().Activity($"Successully parsed {modProject.LastBackup} to DateTime.");
modData.LastBackup = lastBackup.ToLocalTime();
}
else
{
Log.Here().Error($"Could not convert {m.LastBackupUTC} to DateTime.");
}
}
}
}
}
;
}
}
catch (Exception ex)
{
Log.Here().Error("Error loading managed projects:");
Log.Here().Error(ex.ToString());
}
return(Unit.Default);
}
public static async Task <List <ModProjectData> > LoadModProjectsAsync(DOS2DEModuleData Data, bool clearExisting = false)
{
if (clearExisting)
{
Log.Here().Important("Clearing mod projects");
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
Data.ModProjects.Clear();
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
Data.ModProjects.Clear();
}
}
List <ModProjectData> newItems = new List <ModProjectData>();
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DEDataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DEDataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity($"Loading DOS2 projects from mods directory at: {modsPath}");
//DirectoryInfo modsRoot = new DirectoryInfo(modsPath);
//var modFolders = modsRoot.GetDirectories().Where(s => !IgnoredFolders.Contains(s.Name));
DirectoryEnumerationFilters filters = new DirectoryEnumerationFilters()
{
InclusionFilter = (f) =>
{
return(!IgnoredFolders.Contains(f.FileName));
},
};
//var modFolders = await Observable.Start(() =>
//{
// return Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
//}, RxApp.TaskpoolScheduler);
var modFolders = Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
if (modFolders != null)
{
foreach (string modFolder in modFolders)
{
try
{
var modFolderName = Path.GetFileName(modFolder);
Log.Here().Activity($"Checking project mod folder: {modFolderName}");
var metaFilePath = Path.Combine(modFolder, "meta.lsx");
if (File.Exists(metaFilePath))
{
Log.Here().Activity($"Meta file found for project {modFolderName}. Reading file.");
ModProjectData modProjectData = new ModProjectData();
await modProjectData.LoadAllDataAsync(metaFilePath, projectsPath);
Log.Here().Activity($"Finished reading meta files for mod: {modProjectData.ModuleInfo.Name}");
if (!clearExisting)
{
var previous = Data.ModProjects.Items.FirstOrDefault(p => p.FolderName == modProjectData.FolderName);
if (previous != null)
{
if (previous.DataIsNewer(modProjectData))
{
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
previous.UpdateData(modProjectData);
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
previous.UpdateData(modProjectData);
}
}
}
else
{
newItems.Add(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
}
catch (Exception ex)
{
Log.Here().Error($"Error parsing mod folder ${modFolder}:");
Log.Here().Error(ex.ToString());
}
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DEDataDirectory);
}
}
return(newItems);
}
public static string CustomLocaleDirectory(DOS2DEModuleData Data, ModProjectData modProject)
{
return(Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName, @"LocaleEditor\"));
}
