public async Task AddFilesAsync()
{
Logger.Trace("Files are being added to {0}", FullPath);
// Run as a load operation
using (await Archive.LoadOperation.RunAsync())
{
// Lock the access to the archive
using (await Archive.ArchiveLock.LockAsync())
{
// Get the files
FileBrowserResult result = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Archive_AddFiles_Header,
MultiSelection = true
});
if (result.CanceledByUser)
{
return;
}
// Add every file
await AddFilesAsync(result.SelectedFiles);
}
}
}
public Task <FileBrowserResult> BrowseToOpen(string defaultDirectory, IList <string> extensions)
{
var result = new FileBrowserResult();
var dialog = new OpenFileDialog()
{
InitialDirectory = defaultDirectory
};
if (extensions?.Any() == true)
{
var filterBuilder = new StringBuilder();
for (int i = 0; i < extensions.Count; i++)
{
if (i > 0)
{
filterBuilder.Append("|");
}
string ext = extensions[i].Replace(".", string.Empty);
filterBuilder.Append($"{ext.ToUpper()} Files (*.{ext})|*.{ext}");
}
dialog.Filter = filterBuilder.ToString();
}
if (dialog.ShowDialog() == true)
{
result.Confirmed = true;
result.FileName = dialog.FileName;
}
return(Task.FromResult(result));
}
public async Task OpenArchiveExplorerAsync()
{
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_ArchiveExplorer_FileSelectionHeader,
DefaultDirectory = SelectedType.Modes.SelectedValue.GetAttribute <GameModeBaseAttribute>()?.Game?.GetInstallDir(false).FullPath,
ExtensionFilter = SelectedType.FileExtension.GetFileFilterItem.ToString(),
MultiSelection = true,
});
if (fileResult.CanceledByUser)
{
return;
}
// Get the manager
using IArchiveDataManager manager = SelectedType.GetManager(Utility_Archives_TypeViewModel.ArchiveMode.Explorer);
try
{
// Show the Archive Explorer
await Services.UI.ShowArchiveExplorerAsync(manager, fileResult.SelectedFiles.ToArray());
}
catch (Exception ex)
{
Logger.Error(ex, "Archive explorer");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Archive_CriticalError);
}
}
public Task <FileBrowserResult> BrowseToSave(string defaultDirectory, string defaultFileName)
{
var savePanel = NSSavePanel.SavePanel;
var result = new FileBrowserResult();
savePanel.CanCreateDirectories = true;
savePanel.CanSelectHiddenExtension = true;
if (savePanel.RunModal(defaultDirectory, defaultFileName) == 1)
{
result.Confirmed = true;
result.FileName = savePanel.Filename;
}
return(Task.FromResult(result));
}
public async Task EncodeAsync()
{
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Decoder_EncodeFileSelectionHeader,
DefaultDirectory = SelectedType.Game?.GetInstallDir(false).FullPath,
ExtensionFilter = SelectedType.GetFileFilter(),
MultiSelection = true
});
if (fileResult.CanceledByUser)
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
try
{
// Process the files
await Task.Run(() => ProcessFile(fileResult.SelectedFiles, destinationResult.SelectedDirectory, false));
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Decoder_EncodeSuccess);
}
catch (NotImplementedException ex)
{
Logger.Debug(ex, "Encoding files");
await Services.MessageUI.DisplayMessageAsync(Resources.NotImplemented, MessageType.Error);
}
catch (Exception ex)
{
Logger.Error(ex, "Encoding files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Decoder_EncodeError);
}
}
public Task <FileBrowserResult> BrowseToOpen(string defaultDirectory, IList <string> extensions)
{
var openPanel = NSOpenPanel.OpenPanel;
var result = new FileBrowserResult();
openPanel.CanChooseDirectories = false;
openPanel.CanChooseFiles = true;
openPanel.CanCreateDirectories = false;
if (openPanel.RunModal(defaultDirectory, null, extensions?.ToArray()) == 1)
{
result.Confirmed = true;
result.FileName = openPanel.Filename;
}
return(Task.FromResult(result));
}
public Task <FileBrowserResult> BrowseToSave(string defaultDirectory, string defaultFileName)
{
var result = new FileBrowserResult();
var dialog = new SaveFileDialog()
{
InitialDirectory = defaultDirectory,
FileName = defaultFileName
};
if (dialog.ShowDialog() == true)
{
result.Confirmed = true;
result.FileName = dialog.FileName;
}
return(Task.FromResult(result));
}
public async Task ConvertAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Attempt to get a default directory
FileSystemPath?defaultDir = SelectedType.SelectedMode.GetDefaultDir();
// Make sure the directory exists
if (defaultDir?.DirectoryExists != true)
{
defaultDir = null;
}
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Converter_FileSelectionHeader,
DefaultDirectory = defaultDir?.FullPath,
ExtensionFilter = SelectedType.SourceFileExtension.GetFileFilterItem.ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser)
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
// Allow the user to select the file extension to export as
FileExtensionSelectionDialogResult extResult = await Services.UI.SelectFileExtensionAsync(new FileExtensionSelectionDialogViewModel(SelectedType.ConvertFormats, Resources.Utilities_Converter_ExportExtensionHeader));
if (extResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Convert every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(new FileExtension(extResult.SelectedFileFormat, multiple: true)).GetNonExistingFileName();
// Convert the file
SelectedType.Convert(context, file.Name, destinationFile);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Converter_Success);
}
catch (Exception ex)
{
Logger.Error(ex, "Converting files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Converter_Error);
}
}
finally
{
IsLoading = false;
}
}
public async Task ConvertBackAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Converter_FileSelectionHeader,
ExtensionFilter = new FileFilterItemCollection(SelectedType.ConvertFormats.Select(x => new FileFilterItem($"*{x}", x.ToUpper()))).ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser)
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
// Get the state
object?state = await SelectedType.GetConvertBackStateAsync();
if (state is null)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Convert every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(SelectedType.SourceFileExtension).GetNonExistingFileName();
// Convert the file
SelectedType.ConvertBack(context, file, destinationFile.Name, state);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Converter_Success);
}
catch (Exception ex)
{
Logger.Error(ex, "Converting files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Converter_Error);
}
}
finally
{
IsLoading = false;
}
}
public async Task SerializeAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Serializers_FileSelectionHeader,
ExtensionFilter = new FileFilterItem("*.json", "JSON").ToString(),
MultiSelection = true,
});
if (fileResult.CanceledByUser || !fileResult.SelectedFiles.Any())
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(destinationResult.SelectedDirectory);
SelectedType.SelectedMode.InitContext(context);
// Serialize every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(SelectedType.FileExtension).GetNonExistingFileName();
// Deserialize the file JSON
object data = JsonHelpers.DeserializeFromFile(file, SelectedType.Type);
// Serialize the data to the destination file
SelectedType.Serialize(context, destinationFile.Name, data);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Serializers_SerializeSuccess);
}
catch (Exception ex)
{
Logger.Error(ex, "Serializing files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Serializers_SerializeError);
}
}
finally
{
IsLoading = false;
}
}
public async Task DeserializeAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Attempt to get a default directory
FileSystemPath?defaultDir = SelectedType.SelectedMode.GetDefaultDir();
// Make sure the directory exists
if (defaultDir?.DirectoryExists != true)
{
defaultDir = null;
}
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Serializers_FileSelectionHeader,
DefaultDirectory = defaultDir?.FullPath,
ExtensionFilter = SelectedType.FileExtension.GetFileFilterItem.ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser || !fileResult.SelectedFiles.Any())
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Deserialize every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
object?fileObj = SelectedType.Deserialize(context, file.Name);
if (fileObj is null)
{
Logger.Warn("Deserialized file was null");
continue;
}
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(new FileExtension(".json")).GetNonExistingFileName();
// Serialize as JSON
JsonHelpers.SerializeToFile(fileObj, destinationFile);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Serializers_DeserializeSuccess);
}
catch (Exception ex)
{
Logger.Error(ex, "Deserializing files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Serializers_DeserializeError);
}
}
finally
{
IsLoading = false;
}
}
public async Task LogAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Attempt to get a default directory
FileSystemPath?defaultDir = SelectedType.SelectedMode.GetDefaultDir();
// Make sure the directory exists
if (defaultDir?.DirectoryExists != true)
{
defaultDir = null;
}
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Serializers_FileSelectionHeader,
DefaultDirectory = defaultDir?.FullPath,
ExtensionFilter = SelectedType.FileExtension.GetFileFilterItem.ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser || !fileResult.SelectedFiles.Any())
{
return;
}
try
{
await Task.Run(() =>
{
MemorySerializerLog log = new();
using RCPContext context = new(fileResult.SelectedFiles.First().Parent, log : log);
SelectedType.SelectedMode.InitContext(context);
try
{
// Deserialize every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
SelectedType.Deserialize(context, file.Name);
}
}
finally
{
Log = log.GetString;
}
});
}
catch (Exception ex)
{
Logger.Error(ex, "Logging serialized files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Serializers_LogError);
}
}
finally
{
IsLoading = false;
}
}
