/// <inheritdoc />
public async Task <LoadResult> LoadFile(IStateInfo stateInfo, ArchiveFileInfo afi, Guid pluginId, LoadFileContext loadFileContext)
{
// If stateInfo is no archive state
if (!(stateInfo.PluginState is IArchiveState archiveState))
{
throw new InvalidOperationException("The state represents no archive.");
}
// If file is already loaded
var absoluteFilePath = UPath.Combine(stateInfo.AbsoluteDirectory, stateInfo.FilePath.ToRelative(), afi.FilePath.ToRelative());
if (IsLoaded(absoluteFilePath))
{
return(new LoadResult(GetLoadedFile(absoluteFilePath)));
}
// 1. Create file system action
var fileSystemAction = new Func <IStreamManager, IFileSystem>(streamManager =>
FileSystemFactory.CreateAfiFileSystem(stateInfo, UPath.Root, streamManager));
// 2. Load file
// ArchiveFileInfos have stateInfo as their parent, if loaded like this
var loadResult = await LoadFile(fileSystemAction, afi.FilePath, stateInfo, pluginId, loadFileContext);
if (!loadResult.IsSuccessful)
{
return(loadResult);
}
// 3. Add archive child to parent
// ArchiveChildren are only added, if a file is loaded like this
stateInfo.ArchiveChildren.Add(loadResult.LoadedState);
return(loadResult);
}
public ArchiveContext(ContextNode contextNode, IContext parentContext, IInternalPluginManager pluginManager) : base(pluginManager, contextNode)
{
ContractAssertions.IsNotNull(contextNode, nameof(contextNode));
ContractAssertions.IsNotNull(parentContext, nameof(parentContext));
_stateInfo = contextNode.StateInfo;
_archiveState = _stateInfo.PluginState as IArchiveState;
_archiveFileSystem = FileSystemFactory.CreateAfiFileSystem(_stateInfo);
_parentContext = parentContext;
}
public async Task <IList <AnmcNamedImageRessource> > Load(string file)
{
if (_archiveStateInfo != null)
{
Close();
}
// Load archive
_archiveStateInfo = await LoadArchive(file);
// Load images
var archiveFileSystem = FileSystemFactory.CreateAfiFileSystem(ArchiveState, UPath.Root, _archiveStateInfo.StreamManager);
_imageStateInfos = await LoadImages(archiveFileSystem);
// Load point mappings
var mappings = await LoadPvb(archiveFileSystem);
_pointMappings = await LoadPbis(archiveFileSystem, mappings);
// Load RES.bin
var nameIndices = await LoadResBin(archiveFileSystem);
// Create image providers
var imageStates = _imageStateInfos.Select(x => x.State as IImageState).ToArray();
var imageProviders = new ImageProvider[_imageStateInfos.Count];
for (var i = 0; i < imageProviders.Length; i++)
{
imageProviders[i] = new ImageProvider(new KanvasImage(imageStates[i], imageStates[i].Images[0]));
}
// Create final image ressources
var result = new List <AnmcNamedImageRessource>();
for (var i = 0; i < Math.Min(_pointMappings.Count, nameIndices.Count); i++)
{
var nameIndex = nameIndices.First(x => x.Value.pbiIndex == i);
var imageProvider = imageProviders[nameIndex.Value.imageIndex];
var partIndex = 0;
var imageRessources = new List <AnmcImageRessource>();
for (var mappingIndex = 0; mappingIndex < _pointMappings[i].Count; mappingIndex += 6)
{
var points = _pointMappings[i].Skip(mappingIndex).Take(6).ToArray();
var imageRessource = new AnmcImageRessource(imageProvider, points, $"{nameIndex.Key} Part {partIndex++}");
imageRessources.Add(imageRessource);
}
result.Add(new AnmcNamedImageRessource(nameIndex.Key, imageRessources));
}
return(result);
}
public ArchiveForm(IStateInfo stateInfo, IArchiveFormCommunicator communicator, PluginManager pluginManager, IProgressContext progress)
{
InitializeComponent();
_stateInfo = stateInfo;
_communicator = communicator;
_pluginManager = pluginManager;
_progress = progress;
_archiveFileSystem = FileSystemFactory.CreateAfiFileSystem(stateInfo);
_openingFiles = new List <IArchiveFileInfo>();
_changedDirectories = new HashSet <UPath>();
_selectedPath = UPath.Root;
_searchTerm = new SearchTerm(searchTextBox);
_searchTerm.TextChanged += searchTerm_TextChanged;
_asyncOperation = new AsyncOperation();
_asyncOperation.Started += asyncOperation_Started;
_asyncOperation.Finished += asyncOperation_Finished;
folderView.Expanded += folderView_Expanded;
folderView.Collapsed += folderView_Collapsed;
folderView.CellFormatting += folderView_CellFormatting;
folderView.SelectedItemChanged += folderView_SelectedItemChanged;
fileView.SelectedItemsChanged += fileView_SelectedItemsChanged;
fileView.CellDoubleClick += fileView_CellDoubleClick;
fileView.CellFormatting += fileView_CellFormatting;
searchClearCommand.Executed += searchClearCommand_Executed;
cancelCommand.Executed += cancelCommand_Executed;
saveCommand.Executed += SaveCommand_Executed;
saveAsCommand.Executed += SaveAsCommand_Executed;
openCommand.Executed += openCommand_Executed;
extractFileCommand.Executed += extractFileCommand_Executed;
replaceFileCommand.Executed += replaceFileCommand_Executed;
renameFileCommand.Executed += RenameFileCommand_Executed;
deleteFileCommand.Executed += DeleteFileCommand_Executed;
extractDirectoryCommand.Executed += extractDirectoryCommand_Executed;
replaceDirectoryCommand.Executed += replaceDirectoryCommand_Executed;
renameDirectoryCommand.Executed += renameDirectoryCommand_Executed;
addDirectoryCommand.Executed += addDirectoryCommand_Executed;
deleteDirectoryCommand.Executed += deleteDirectoryCommand_Executed;
UpdateProperties();
LoadDirectories();
UpdateFiles(_selectedPath);
}
public void Save(UPath savePath)
{
// 1. Create file system for archive
var archiveFileSystem = FileSystemFactory.CreateAfiFileSystem(ArchiveState, UPath.Root, _archiveStateInfo.StreamManager);
// 2. Save PVB and PBIs
var distinctPointMappings = _pointMappings.SelectMany(x => x).Batch(6).Select(x => x.OrderBy(y => y.v).ThenBy(y => y.u)).SelectMany(x => x).Distinct().ToArray();
SavePvb(archiveFileSystem, distinctPointMappings);
SavePbis(archiveFileSystem, _pointMappings, distinctPointMappings);
// 3. Save images
foreach (var stateInfo in _imageStateInfos)
{
_pluginManager.SaveFile(stateInfo);
}
// 3. Save original archive
_pluginManager.SaveFile(_archiveStateInfo, savePath);
}
private async void Save(bool saveAs)
{
var wasSuccessful = await _communicator.Save(saveAs);
if (!wasSuccessful)
{
return;
}
_changedDirectories.Clear();
_archiveFileSystem = FileSystemFactory.CreateAfiFileSystem(_stateInfo);
_selectedPath = UPath.Root;
await Application.Instance.InvokeAsync(() =>
{
LoadDirectories();
UpdateFiles(UPath.Root);
UpdateProperties();
_communicator.Update(true, false);
});
}
