public void SignalDestroy()
{
if (RootBlock != null)
{
RootBlock.SignalDestroy();
}
}
public void OnLocationChanged()
{
if (RootBlock != null)
{
RootBlock.FireAction(Anchor.OnLocationObtained);
}
}
public static void CreateRoot(int x, int y, int id = -1, int colorsId = -1)
{
if (id == -1)
{
id = Root.Count;
}
if (colorsId == -1)
{
colorsId = Colors.GetRandomFreeId();
}
var root = new Root();
root.id = id;
Root.Add(id, root);
CreateRootCanvas(id, colorsId);
CreateVisualsCanvas(id);
var block = RootBlock.Create(x, y, id);
root.block = block;
CreateLeftRootPanel(id);
CreateRightDirectionsPanels(id);
CreateSlicedAudioClip(id);
}
public void AttachFormData(short formID, FieldList storage)
{
if ((RootBlock != null) && (storage != null))
{
RootBlock.AttachFormData(formID, storage);
}
}
//
internal void ParsePredicate(Token tok)
{
Advance(); //past 'predicate
//
AtomTypeDef clauseType = BuiltinDefs.Belief;
if (CurrentToken.Kind == TokenKind.Type)
{
clauseType = RootBlock.InternAtomTypeDef(CurrentToken);
Advance(); //past clauseType
}
//
Token name = CurrentToken;
Advance(); //past name
//
Token specName = TokenInstance.CSharp.ELEMENT;
if (CurrentToken.Kind == TokenKind.RoundList)
{
specName = CurrentList[0];
Advance(); //past (specname)
}
PredicateDef predDef = new PredicateDef(name, clauseType, specName);
ParseProperties(predDef);
RootBlock.AddEntityDef(predDef);
}
public void ParseFile(string moduleName, Stream inStream, Transpiler t)
{
Translator = t;
RootBlock = RootBlock.Create(moduleName + "Module");
t.RootBlock = RootBlock;
Preprocessor preprocessor = new Preprocessor();
TokenList list = preprocessor.Read(inStream);
#if DEBUG_TOKENIZER
Debug.Print("");
Debug.Print("");
//DebugTextWriter writer = new DebugTextWriter();
StringWriter writer = new StringWriter();
list.Print(writer);
Debug.Print(writer.ToString());
Debug.Print("");
Debug.Print("");
#endif
//
//PushPolicy(RootPolicy);
CreateState(list);
//Visit(RootBlock);
PushDialect(new ParserDialect(this));
ParseLines(RootBlock);
PopState();
//PopPolicy();
//TODO:This should go in the compiler class.
RootBlock.Resolve();
t.Visit(RootBlock);
//
t.Close();
}
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{
Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(partition.Start);
RootBlock rootBlock = Marshal.ByteArrayToStructureBigEndian <RootBlock>(rootBlockSector);
var sbInformation = new StringBuilder();
sbInformation.AppendLine("SmartFileSystem");
sbInformation.AppendFormat("Volume version {0}", rootBlock.version).AppendLine();
sbInformation.AppendFormat("Volume starts on device byte {0} and ends on byte {1}", rootBlock.firstbyte,
rootBlock.lastbyte).AppendLine();
sbInformation.
AppendFormat("Volume has {0} blocks of {1} bytes each", rootBlock.totalblocks, rootBlock.blocksize).
AppendLine();
sbInformation.AppendFormat("Volume created on {0}",
DateHandlers.UnixUnsignedToDateTime(rootBlock.datecreated).AddYears(8)).
AppendLine();
sbInformation.AppendFormat("Bitmap starts in block {0}", rootBlock.bitmapbase).AppendLine();
sbInformation.AppendFormat("Admin space container starts in block {0}", rootBlock.adminspacecontainer).
AppendLine();
sbInformation.AppendFormat("Root object container starts in block {0}", rootBlock.rootobjectcontainer).
AppendLine();
sbInformation.
AppendFormat("Root node of the extent B-tree resides in block {0}", rootBlock.extentbnoderoot).
AppendLine();
sbInformation.AppendFormat("Root node of the object B-tree resides in block {0}", rootBlock.objectnoderoot).
AppendLine();
if (rootBlock.bits.HasFlag(Flags.CaseSensitive))
{
sbInformation.AppendLine("Volume is case sensitive");
}
if (rootBlock.bits.HasFlag(Flags.RecycledFolder))
{
sbInformation.AppendLine("Volume moves deleted files to a recycled folder");
}
information = sbInformation.ToString();
XmlFsType = new FileSystemType
{
CreationDate = DateHandlers.UnixUnsignedToDateTime(rootBlock.datecreated).AddYears(8),
CreationDateSpecified = true,
Clusters = rootBlock.totalblocks,
ClusterSize = rootBlock.blocksize,
Type = "SmartFileSystem"
};
}
public void OnLocationUnavailable()
{
if (RootBlock != null)
{
RootBlock.FireAction(Anchor.OnLocationNotAvailable);
}
}
protected override void OnRootChanged(RootBlock oldRoot, RootBlock newRoot)
{
base.OnRootChanged(oldRoot, newRoot);
if (newRoot != null)
{
Reparse();
}
}
public static bool Create(RootBlock b, out RootBlockSerialized result)
{
result = null;
result = new RootBlockSerialized {
X = b.logic.X, Y = b.logic.Y, Id = b.rootId, ColorsId = Roots.Root[b.rootId].palette.ColorsId
};
return(true);
}
public string Generate()
{
if (Options.IsCSharpGenerator && Options.CompileCode)
{
return(RootBlock.GenerateUnformatted(Options).ToString());
}
return(RootBlock.Generate(Options));
}
protected override void OnRootChanged(RootBlock oldRoot, RootBlock newRoot)
{
base.OnRootChanged(oldRoot, newRoot);
if (newRoot != null && !attributesAdded)
{
attributesAdded = true;
AttributeBlock.AddAttributes(this);
}
}
public void SignalShow()
{
if (RootBlock != null)
{
RootBlock.SignalShow();
}
IsHitTestVisible = true;
}
public void SignalHide()
{
IsHitTestVisible = false;
if (RootBlock != null)
{
RootBlock.SignalHide();
}
}
public SetCaretPositionAction(
RootBlock root,
TextBoxBlock toFocus,
SetFocusOptions options,
int caretPosition)
: base(toFocus, options)
{
CaretPosition = caretPosition;
Text = toFocus;
}
public Redrawer(RootBlock rootBlock, bool shouldRedrawAtTheEnd)
: base()
{
this.ShouldRedrawAtTheEnd = shouldRedrawAtTheEnd;
RootBlock = rootBlock;
if (RootBlock != null)
{
Root = RootBlock.MyRootControl;
Root.RedrawRequestsCount++;
}
}
static RootBlock MarshalRootBlock(byte[] block)
{
byte[] tmp = new byte[228];
Array.Copy(block, 0, tmp, 0, 24);
Array.Copy(block, block.Length - 200, tmp, 28, 200);
RootBlock root = Marshal.ByteArrayToStructureBigEndian <RootBlock>(tmp);
root.hashTable = new uint[(block.Length - 224) / 4];
for (int i = 0; i < root.hashTable.Length; i++)
{
root.hashTable[i] = BigEndianBitConverter.ToUInt32(block, 24 + i * 4);
}
return(root);
}
void ParseContext(AstNode parent)
{
Advance();//past 'context
Token name = CurrentToken;
RootBlock.AddEntityDef(new EntityDef(name));
Advance();//past name
//
ContextDef def = new ContextDef(name);
parent.AddChild(def);
//
do
{
CreateState(CurrentList);
ParseContextItem(def);
PopState();
} while (Advance());
}
private void SubscribeBlock(Block block)
{
ContainerBlock oldParent = block.Parent;
RootBlock oldRoot = block.Root;
// set block's parent
block.Parent = this.Parent;
block.MyControl.Parent = Parent.MyControl as ContainerControl;
// set block's root
if (Parent.Root != null)
{
block.Root = Parent.Root;
block.MyControl.Root = Parent.Root.MyRootControl;
}
block.NotifyParentChanged(oldParent);
block.NotifyRootChanged(oldRoot);
// subscribe to block's events
block.KeyDown += RaiseKeyDown;
}
public void Initialise(NodeData source)
{
// save node data for the future use
data = source;
// try to create node contents
if ((data != null) && (data.Root != null))
{
BlockBase block = Core.UIFactory.CreateAndInitialiseBlock(parentView, this, null, data.Root, data.RootContent, true);
if (block != null)
{
// always fill entire area of the node with root element
block.HorizontalAlignment = HorizontalAlignment.Stretch;
block.VerticalAlignment = VerticalAlignment.Stretch;
// show block
Content = block;
}
}
// we are done
if (RootBlock != null)
{
// check for native alerts to be triggered on node load and add trigger if it is not there
if ((NativeMessageBox != null) && !NativeMessageBox.IntendedForCustomAction && !RootBlock.HasCustomAction(Anchor.OnNodeLoaded, CustomActions.NativeMessageBox))
{
RootBlock.AddAction(
Anchor.OnNodeLoaded,
new CustomAction(ActionSet.DefaultActionID, new string[] { CustomActions.NativeMessageBox }));
}
// root block may need a special setup
RootBlock.SignalIsRoot();
// schedule launch for OnNodeLoaded actions
ThreadHelper.Sync(() => RootBlock.FireAction(Anchor.OnNodeLoaded));
}
}
public virtual string Generate()
{
return(RootBlock.Generate());
}
public bool Identify(IMediaImage imagePlugin, Partition partition)
{
if (partition.Start >= partition.End)
{
return(false);
}
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
// Boot block is unless defined otherwise, 2 blocks
// Funny, you may need boot block to find root block if it's not in standard place just to know size of
// block size and then read the whole boot block.
// However while you can set a block size different from the sector size on formatting, the bootblock block
// size for floppies is the sector size, and for RDB is usually is the hard disk sector size,
// so this is not entirely wrong...
byte[] sector = imagePlugin.ReadSectors(0 + partition.Start, 2);
BootBlock bblk = Marshal.ByteArrayToStructureBigEndian <BootBlock>(sector);
// AROS boot floppies...
if (sector.Length >= 512 && sector[510] == 0x55 && sector[511] == 0xAA &&
(bblk.diskType & FFS_MASK) != FFS_MASK && (bblk.diskType & MUFS_MASK) != MUFS_MASK)
{
sector = imagePlugin.ReadSectors(1 + partition.Start, 2);
bblk = Marshal.ByteArrayToStructureBigEndian <BootBlock>(sector);
}
// Not FFS or MuFS?
if ((bblk.diskType & FFS_MASK) != FFS_MASK && (bblk.diskType & MUFS_MASK) != MUFS_MASK)
{
return(false);
}
// Clear checksum on sector
sector[4] = sector[5] = sector[6] = sector[7] = 0;
uint bsum = AmigaBootChecksum(sector);
DicConsole.DebugWriteLine("AmigaDOS plugin", "bblk.checksum = 0x{0:X8}", bblk.checksum);
DicConsole.DebugWriteLine("AmigaDOS plugin", "bsum = 0x{0:X8}", bsum);
ulong bRootPtr = 0;
// If bootblock is correct, let's take its rootblock pointer
if (bsum == bblk.checksum)
{
bRootPtr = bblk.root_ptr + partition.Start;
DicConsole.DebugWriteLine("AmigaDOS plugin", "Bootblock points to {0} as Rootblock", bRootPtr);
}
ulong[] rootPtrs =
{
bRootPtr + partition.Start, (partition.End - partition.Start + 1) / 2 + partition.Start - 2,
(partition.End - partition.Start + 1) / 2 + partition.Start - 1,
(partition.End - partition.Start + 1) / 2 +
partition.Start,
(partition.End - partition.Start + 1) / 2 + partition.Start + 4
};
RootBlock rblk = new RootBlock();
// So to handle even number of sectors
foreach (ulong rootPtr in rootPtrs.Where(rootPtr => rootPtr < partition.End && rootPtr >= partition.Start))
{
DicConsole.DebugWriteLine("AmigaDOS plugin", "Searching for Rootblock in sector {0}", rootPtr);
sector = imagePlugin.ReadSector(rootPtr);
rblk.type = BigEndianBitConverter.ToUInt32(sector, 0x00);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rblk.type = {0}", rblk.type);
if (rblk.type != TYPE_HEADER)
{
continue;
}
rblk.hashTableSize = BigEndianBitConverter.ToUInt32(sector, 0x0C);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rblk.hashTableSize = {0}", rblk.hashTableSize);
uint blockSize = (rblk.hashTableSize + 56) * 4;
uint sectorsPerBlock = (uint)(blockSize / sector.Length);
DicConsole.DebugWriteLine("AmigaDOS plugin", "blockSize = {0}", blockSize);
DicConsole.DebugWriteLine("AmigaDOS plugin", "sectorsPerBlock = {0}", sectorsPerBlock);
if (blockSize % sector.Length > 0)
{
sectorsPerBlock++;
}
if (rootPtr + sectorsPerBlock >= partition.End)
{
continue;
}
sector = imagePlugin.ReadSectors(rootPtr, sectorsPerBlock);
// Clear checksum on sector
rblk.checksum = BigEndianBitConverter.ToUInt32(sector, 20);
sector[20] = sector[21] = sector[22] = sector[23] = 0;
uint rsum = AmigaChecksum(sector);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rblk.checksum = 0x{0:X8}", rblk.checksum);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rsum = 0x{0:X8}", rsum);
rblk.sec_type = BigEndianBitConverter.ToUInt32(sector, sector.Length - 4);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rblk.sec_type = {0}", rblk.sec_type);
if (rblk.sec_type == SUBTYPE_ROOT && rblk.checksum == rsum)
{
return(true);
}
}
return(false);
}
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{
Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
StringBuilder sbInformation = new StringBuilder();
XmlFsType = new FileSystemType();
information = null;
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
byte[] bootBlockSectors = imagePlugin.ReadSectors(0 + partition.Start, 2);
BootBlock bootBlk = Marshal.ByteArrayToStructureBigEndian <BootBlock>(bootBlockSectors);
bootBlk.bootCode = new byte[bootBlockSectors.Length - 12];
Array.Copy(bootBlockSectors, 12, bootBlk.bootCode, 0, bootBlk.bootCode.Length);
bootBlockSectors[4] = bootBlockSectors[5] = bootBlockSectors[6] = bootBlockSectors[7] = 0;
uint bsum = AmigaBootChecksum(bootBlockSectors);
ulong bRootPtr = 0;
// If bootblock is correct, let's take its rootblock pointer
if (bsum == bootBlk.checksum)
{
bRootPtr = bootBlk.root_ptr + partition.Start;
DicConsole.DebugWriteLine("AmigaDOS plugin", "Bootblock points to {0} as Rootblock", bRootPtr);
}
ulong[] rootPtrs =
{
bRootPtr + partition.Start, (partition.End - partition.Start + 1) / 2 + partition.Start - 2,
(partition.End - partition.Start + 1) / 2 + partition.Start - 1,
(partition.End - partition.Start + 1) / 2 +
partition.Start,
(partition.End - partition.Start + 1) / 2 + partition.Start + 4
};
RootBlock rootBlk = new RootBlock();
byte[] rootBlockSector = null;
bool rootFound = false;
uint blockSize = 0;
// So to handle even number of sectors
foreach (ulong rootPtr in rootPtrs.Where(rootPtr => rootPtr < partition.End && rootPtr >= partition.Start))
{
DicConsole.DebugWriteLine("AmigaDOS plugin", "Searching for Rootblock in sector {0}", rootPtr);
rootBlockSector = imagePlugin.ReadSector(rootPtr);
rootBlk.type = BigEndianBitConverter.ToUInt32(rootBlockSector, 0x00);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.type = {0}", rootBlk.type);
if (rootBlk.type != TYPE_HEADER)
{
continue;
}
rootBlk.hashTableSize = BigEndianBitConverter.ToUInt32(rootBlockSector, 0x0C);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.hashTableSize = {0}", rootBlk.hashTableSize);
blockSize = (rootBlk.hashTableSize + 56) * 4;
uint sectorsPerBlock = (uint)(blockSize / rootBlockSector.Length);
DicConsole.DebugWriteLine("AmigaDOS plugin", "blockSize = {0}", blockSize);
DicConsole.DebugWriteLine("AmigaDOS plugin", "sectorsPerBlock = {0}", sectorsPerBlock);
if (blockSize % rootBlockSector.Length > 0)
{
sectorsPerBlock++;
}
if (rootPtr + sectorsPerBlock >= partition.End)
{
continue;
}
rootBlockSector = imagePlugin.ReadSectors(rootPtr, sectorsPerBlock);
// Clear checksum on sector
rootBlk.checksum = BigEndianBitConverter.ToUInt32(rootBlockSector, 20);
rootBlockSector[20] = rootBlockSector[21] = rootBlockSector[22] = rootBlockSector[23] = 0;
uint rsum = AmigaChecksum(rootBlockSector);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.checksum = 0x{0:X8}", rootBlk.checksum);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rsum = 0x{0:X8}", rsum);
rootBlk.sec_type = BigEndianBitConverter.ToUInt32(rootBlockSector, rootBlockSector.Length - 4);
DicConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.sec_type = {0}", rootBlk.sec_type);
if (rootBlk.sec_type != SUBTYPE_ROOT || rootBlk.checksum != rsum)
{
continue;
}
rootBlockSector = imagePlugin.ReadSectors(rootPtr, sectorsPerBlock);
rootFound = true;
break;
}
if (!rootFound)
{
return;
}
rootBlk = MarshalRootBlock(rootBlockSector);
string diskName = StringHandlers.PascalToString(rootBlk.diskName, Encoding);
switch (bootBlk.diskType & 0xFF)
{
case 0:
sbInformation.Append("Amiga Original File System");
XmlFsType.Type = "Amiga OFS";
break;
case 1:
sbInformation.Append("Amiga Fast File System");
XmlFsType.Type = "Amiga FFS";
break;
case 2:
sbInformation.Append("Amiga Original File System with international characters");
XmlFsType.Type = "Amiga OFS";
break;
case 3:
sbInformation.Append("Amiga Fast File System with international characters");
XmlFsType.Type = "Amiga FFS";
break;
case 4:
sbInformation.Append("Amiga Original File System with directory cache");
XmlFsType.Type = "Amiga OFS";
break;
case 5:
sbInformation.Append("Amiga Fast File System with directory cache");
XmlFsType.Type = "Amiga FFS";
break;
case 6:
sbInformation.Append("Amiga Original File System with long filenames");
XmlFsType.Type = "Amiga OFS2";
break;
case 7:
sbInformation.Append("Amiga Fast File System with long filenames");
XmlFsType.Type = "Amiga FFS2";
break;
}
if ((bootBlk.diskType & 0x6D754600) == 0x6D754600)
{
sbInformation.Append(", with multi-user patches");
}
sbInformation.AppendLine();
sbInformation.AppendFormat("Volume name: {0}", diskName).AppendLine();
if (bootBlk.checksum == bsum)
{
Sha1Context sha1Ctx = new Sha1Context();
sha1Ctx.Update(bootBlk.bootCode);
sbInformation.AppendLine("Volume is bootable");
sbInformation.AppendFormat("Boot code SHA1 is {0}", sha1Ctx.End()).AppendLine();
}
if (rootBlk.bitmapFlag == 0xFFFFFFFF)
{
sbInformation.AppendLine("Volume bitmap is valid");
}
if (rootBlk.bitmapExtensionBlock != 0x00000000 && rootBlk.bitmapExtensionBlock != 0xFFFFFFFF)
{
sbInformation.AppendFormat("Bitmap extension at block {0}", rootBlk.bitmapExtensionBlock).AppendLine();
}
if ((bootBlk.diskType & 0xFF) == 4 || (bootBlk.diskType & 0xFF) == 5)
{
sbInformation.AppendFormat("Directory cache starts at block {0}", rootBlk.extension).AppendLine();
}
ulong blocks = (partition.End - partition.Start + 1) * imagePlugin.Info.SectorSize / blockSize;
sbInformation.AppendFormat("Volume block size is {0} bytes", blockSize).AppendLine();
sbInformation.AppendFormat("Volume has {0} blocks", blocks).AppendLine();
sbInformation.AppendFormat("Volume created on {0}",
DateHandlers.AmigaToDateTime(rootBlk.cDays, rootBlk.cMins, rootBlk.cTicks))
.AppendLine();
sbInformation.AppendFormat("Volume last modified on {0}",
DateHandlers.AmigaToDateTime(rootBlk.vDays, rootBlk.vMins, rootBlk.vTicks))
.AppendLine();
sbInformation.AppendFormat("Volume root directory last modified on on {0}",
DateHandlers.AmigaToDateTime(rootBlk.rDays, rootBlk.rMins, rootBlk.rTicks))
.AppendLine();
sbInformation.AppendFormat("Root block checksum is 0x{0:X8}", rootBlk.checksum).AppendLine();
information = sbInformation.ToString();
XmlFsType.CreationDate =
DateHandlers.AmigaToDateTime(rootBlk.cDays, rootBlk.cMins, rootBlk.cTicks);
XmlFsType.CreationDateSpecified = true;
XmlFsType.ModificationDate =
DateHandlers.AmigaToDateTime(rootBlk.vDays, rootBlk.vMins, rootBlk.vTicks);
XmlFsType.ModificationDateSpecified = true;
XmlFsType.Dirty = rootBlk.bitmapFlag != 0xFFFFFFFF;
XmlFsType.Clusters = blocks;
XmlFsType.ClusterSize = blockSize;
XmlFsType.VolumeName = diskName;
XmlFsType.Bootable = bsum == bootBlk.checksum;
// Useful as a serial
XmlFsType.VolumeSerial = $"{rootBlk.checksum:X8}";
}
public Redrawer(RootBlock rootBlock)
: this(rootBlock, true)
{
}
public string GenerateUnformatted()
{
return(RootBlock.GenerateUnformatted().ToString());
}
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{
Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(2 + partition.Start);
RootBlock rootBlock = Marshal.ByteArrayToStructureBigEndian <RootBlock>(rootBlockSector);
var sbInformation = new StringBuilder();
XmlFsType = new FileSystemType();
switch (rootBlock.diskType)
{
case AFS_DISK:
case MUAF_DISK:
sbInformation.Append("Professional File System v1");
XmlFsType.Type = "PFS v1";
break;
case PFS2_DISK:
sbInformation.Append("Professional File System v2");
XmlFsType.Type = "PFS v2";
break;
case PFS_DISK:
case MUPFS_DISK:
sbInformation.Append("Professional File System v3");
XmlFsType.Type = "PFS v3";
break;
}
if (rootBlock.diskType == MUAF_DISK ||
rootBlock.diskType == MUPFS_DISK)
{
sbInformation.Append(", with multi-user support");
}
sbInformation.AppendLine();
sbInformation.AppendFormat("Volume name: {0}", StringHandlers.PascalToString(rootBlock.diskname, Encoding)).
AppendLine();
sbInformation.AppendFormat("Volume has {0} free sectors of {1}", rootBlock.blocksfree, rootBlock.diskSize).
AppendLine();
sbInformation.AppendFormat("Volume created on {0}",
DateHandlers.AmigaToDateTime(rootBlock.creationday, rootBlock.creationminute,
rootBlock.creationtick)).AppendLine();
if (rootBlock.extension > 0)
{
sbInformation.AppendFormat("Root block extension resides at block {0}", rootBlock.extension).
AppendLine();
}
information = sbInformation.ToString();
XmlFsType.CreationDate =
DateHandlers.AmigaToDateTime(rootBlock.creationday, rootBlock.creationminute, rootBlock.creationtick);
XmlFsType.CreationDateSpecified = true;
XmlFsType.FreeClusters = rootBlock.blocksfree;
XmlFsType.FreeClustersSpecified = true;
XmlFsType.Clusters = rootBlock.diskSize;
XmlFsType.ClusterSize = imagePlugin.Info.SectorSize;
XmlFsType.VolumeName = StringHandlers.PascalToString(rootBlock.diskname, Encoding);
}
public string Generate()
{
return(RootBlock.Generate());
}
public override string ToString() => RootBlock.ToString();
public IEnumerable <Block> FindBlocks(int kind)
{
return(RootBlock.FindBlocks(kind));
}
protected RootBlockAction(RootBlock root)
{
Param.CheckNotNull(root, "root");
Root = root;
}
