/// <inheritdoc />
public async Task <LoadResult> LoadFile(IStateInfo stateInfo, IArchiveFileInfo afi, LoadFileContext loadFileContext)
{
// If stateInfo is no archive state
if (!(stateInfo.PluginState is IArchiveState _))
{
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
// IArchiveFileInfos have stateInfo as their parent, if loaded like this
var loadResult = await LoadFile(fileSystemAction, afi.FilePath, stateInfo, 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 void Save(Stream output, IArchiveFileInfo file)
{
using var bw = new BinaryWriterX(output);
// Calculate offsets
var subHeaderOffset = _header.dataStart;
var fileOffset = (subHeaderOffset + SubHeaderSize + 0x7F) & ~0x7F;
// Write file
output.Position = fileOffset;
var writtenSize = (file as ArchiveFileInfo).SaveFileData(output);
bw.WriteAlignment(0x80);
// Write sub header
output.Position = subHeaderOffset;
_subHeader.size = (int)writtenSize;
bw.WriteType(_subHeader);
// Write header
output.Position = 0;
_header.size = (int)output.Length;
bw.WriteType(_header);
}
public IList <IArchiveFileInfo> Load(Stream incStream, Stream datStream, string version)
{
using var incBr = new BinaryReaderX(incStream);
var entryCount = (int)(incStream.Length / FileEntrySize);
var entries = incBr.ReadMultiple <AAPackFileEntry>(entryCount);
var nameMapping = AAPackSupport.GetMapping(version);
var result = new IArchiveFileInfo[entryCount];
for (var i = 0; i < entryCount; i++)
{
var subStream = new SubStream(datStream, entries[i].offset, entries[i].compSize);
var compressionMethod = NintendoCompressor.PeekCompressionMethod(subStream);
var fileName = $"{i:00000000}.bin";
if (nameMapping.ContainsKey(entries[i].hash))
{
fileName = nameMapping[entries[i].hash];
}
result[i] = new AAPackArchiveFileInfo(subStream, fileName,
NintendoCompressor.GetConfiguration(compressionMethod), entries[i].uncompSize, entries[i]);
}
return(result);
}
public void Save(Stream output, IArchiveFileInfo file)
{
using var bw = new BinaryWriterX(output);
// Calculate offsets
var sizeOffset = HeaderSize;
var blockCount = file.ContentChanged ? (int)Math.Ceiling(file.FileSize / (float)_header.decompBlockSize) : _blockSizes.Count;
var dataOffset = (sizeOffset + blockCount * 4 + 0x7F) & ~0x7F;
// Chunk stream into blocks
output.Position = dataOffset;
var blockSizes = _blockSizes;
if (file.ContentChanged)
{
blockSizes = GzStream.ChunkStream(file.GetFileData().Result, output, _header.decompBlockSize, 0x80);
_header.decompSize = (int)file.FileSize;
}
else
{
_origStream.Position = 0;
_origStream.CopyTo(output);
}
// Write header
_header.blockCount = blockSizes.Count;
output.Position = 0;
bw.WriteType(_header);
// Write block sizes
bw.WriteMultiple(blockSizes);
}
public Task <bool> Close(IArchiveFileInfo file)
{
return(_mainForm.CloseFile(_stateInfo, file));
//if (_mainFormControl != null && _mainFormControl.InvokeRequired)
// return (Task<bool>)_mainFormControl.Invoke(new Func<IStateInfo, IArchiveFileInfo, Task<bool>>((s1, a1) => _mainForm.CloseFile(s1, a1)), _stateInfo, file);
//return _mainForm.CloseFile(_stateInfo, file);
}
public Task <bool> Open(IArchiveFileInfo file, Guid pluginId)
{
return(_mainForm.OpenFile(_stateInfo, file, pluginId));
//if (_mainFormControl != null && _mainFormControl.InvokeRequired)
// return (Task<bool>)_mainFormControl.Invoke(new Func<IStateInfo, IArchiveFileInfo, Guid, Task<bool>>((s1, a1, g1) => _mainForm.OpenFile(s1, a1, g1)), _stateInfo, file, pluginId);
//return _mainForm.OpenFile(_stateInfo, file, pluginId);
}
public void ReplaceFile(IArchiveFileInfo afi, Stream fileData)
{
using var br = new BinaryReaderX(fileData, true);
if (br.ReadString(5) != "NXTCH")
{
throw new InvalidOperationException("File needs to be a valid NXTCH.");
}
afi.SetFileData(fileData);
}
public void Save(Stream output, IArchiveFileInfo file)
{
var ms = new MemoryStream();
using var bw = new BinaryWriterX(ms);
using var outputBw = new BinaryWriterX(output);
// Calculate offsets
var outerDataOffset = HeaderSize;
var innerDataOffset = (SubHeaderSize + 0x7F) & ~0x7F;
// Write file data
ms.Position = innerDataOffset;
(file as ArchiveFileInfo).SaveFileData(ms);
// Write sub header
var subHeader = new DatSubHeader
{
dataOffset = innerDataOffset,
dataSize = (int)file.FileSize,
fileCount = 1
};
ms.Position = 0;
bw.WriteType(subHeader);
// Compress file
ms.Position = 0;
output.Position = outerDataOffset;
Compressions.IrLz.Build().Compress(ms, output);
// Write header
var header = new DatHeader
{
dataOffset = outerDataOffset,
decompSize = (int)ms.Length,
fileSize = (int)output.Length
};
output.Position = 0;
outputBw.WriteType(header);
}
private bool IsFileLocked(IArchiveFileInfo afi, bool lockOnLoaded)
{
var absolutePath = _stateInfo.AbsoluteDirectory / _stateInfo.FilePath.ToRelative() / afi.FilePath.ToRelative();
var isLoaded = _pluginManager.IsLoaded(absolutePath);
if (!isLoaded)
{
return(false);
}
if (lockOnLoaded)
{
return(true);
}
var openedState = _pluginManager.GetLoadedFile(absolutePath);
return(openedState.StateChanged);
}
public Task <bool> Open(IArchiveFileInfo file)
{
return(Open(file, Guid.Empty));
}
public void Rename(IArchiveFileInfo afi, UPath path)
{
afi.FilePath = path;
}
public FileElement(IArchiveFileInfo afi, Color color)
{
ArchiveFileInfo = afi;
Color = color;
}
public void ReplaceFile(IArchiveFileInfo afi, Stream fileData)
{
afi.SetFileData(fileData);
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, IArchiveFileInfo afi, LoadFileContext loadFileContext)
{
return(_parentPluginManager.LoadFile(stateInfo, afi, loadFileContext));
}
public AfiFileEntry(IArchiveFileInfo afi) : base(afi.FilePath, afi.FileSize)
{
ArchiveFileInfo = afi;
}
public void RemoveFile(IArchiveFileInfo afi)
{
Files.Remove(afi);
_hasDeletedFiles = true;
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, IArchiveFileInfo afi, Guid pluginId)
{
return(_parentPluginManager.LoadFile(stateInfo, afi, new LoadFileContext {
PluginId = pluginId
}));
}
private Task <bool> OpenFile(IArchiveFileInfo afi, Guid pluginId = default)
{
return(pluginId == default ? _communicator.Open(afi) : _communicator.Open(afi, pluginId));
}
public FileElement(IArchiveFileInfo afi) : this(afi, KnownColors.Black)
{
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, IArchiveFileInfo afi)
{
return(LoadFile(stateInfo, afi, new LoadFileContext()));
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IFileState fileState, IArchiveFileInfo afi, Guid pluginId)
{
return(_parentFileManager.LoadFile(fileState, afi, new LoadFileContext {
PluginId = pluginId
}));
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IFileState fileState, IArchiveFileInfo afi, LoadFileContext loadFileContext)
{
return(_parentFileManager.LoadFile(fileState, afi, loadFileContext));
}
public void Rename(IArchiveFileInfo file, UPath renamedPath)
{
InvokeAction(() => _mainForm.RenameFile(_stateInfo, file, renamedPath));
}
public DdtInfoHolder(IArchiveFileInfo fileInfo)
{
File = fileInfo;
Entry = new DdtEntry();
}
