private static void ShiftCoconuts(IndexEntry coconuts, uint shift)
{
//Goto
coconuts.TagData.Seek(coconuts.Offset);
//Initialize IO
using (BinaryReader reader = new BinaryReader(coconuts.TagData))
using (BinaryWriter writer = new BinaryWriter(coconuts.TagData))
{
TagBlock Playbacks = reader.Read <TagBlock>();
TagBlock Scales = reader.Read <TagBlock>();
TagBlock ImportNames = reader.Read <TagBlock>();
TagBlock PitchRangeParameters = reader.Read <TagBlock>();
TagBlock PitchRanges = reader.Read <TagBlock>();
TagBlock Permutations = reader.Read <TagBlock>();
TagBlock CustomPlaybacks = reader.Read <TagBlock>();
TagBlock RuntimePermutationFlags = reader.Read <TagBlock>();
TagBlock Chunks = reader.Read <TagBlock>();
TagBlock Promotions = reader.Read <TagBlock>();
TagBlock ExtraInfos = reader.Read <TagBlock>();
TagBlock[] PromotionRules = new TagBlock[Promotions.Count];
TagBlock[] EmptyString = new TagBlock[Promotions.Count];
TagBlock[] EncodedPermutationSection = new TagBlock[ExtraInfos.Count];
TagBlock[][] EncodedData = new TagBlock[ExtraInfos.Count][];
TagBlock[][] SoundDialogueInfo = new TagBlock[ExtraInfos.Count][];
}
}
public override void Write(IO.EndianWriter stream)
{
Compiler comp = stream.Owner as Compiler;
TagBlock tb = new TagBlock((Import.TagBlock)tagGroup.Block);
tb.Write(stream);
comp.MarkLocationFixup(tagGroup.Name, stream, false);
stream.Write(tagGroup.Name);
stream.Write((int)0);
stream.WriteTag(tagGroup.GroupTag);
if (tagGroup.ParentTag != null)
{
stream.WriteTag(tagGroup.ParentTag);
}
else
{
stream.Write((int)-1);
}
stream.Write(tagGroup.Version);
stream.Write((short)1); // init'd
stream.Write((int)0);
stream.Write((int)0);
stream.Write((int)0);
stream.Write((int)0);
stream.WritePointer(tb.RuntimeAddress);
for (int x = 0; x < 17; x++)
{
stream.Write((int)0); // child group tags
}
stream.Write((int)0); // we don't support that shit, gtfo
stream.Write(comp.Strings.GetNull());
}
private void LoadTagBlockValuesAsNodes(TreeNodeCollection treeNodeCollection, TagBlock block)
{
//Add this TagBlock (chunk) to the Nodes
treeNodeCollection.Add(block.ToString());
int index = treeNodeCollection.Count - 1;
treeNodeCollection[index].ContextMenuStrip = chunkMenu;
//Add the TagBlock (chunk) object to the Tag to let use edit it directly from the node
treeNodeCollection[index].Tag = block;
//Values might be null, dealio
if (block.Values == null) return;
foreach (Value val in block.Values)
{
//the Values can be a bunch of things, we only want the ones that are TagBlockArrays (reflexives)
if (val is TagBlockArray)
{
treeNodeCollection[index].Nodes.Add(val.ToString());
treeNodeCollection[index].Nodes[treeNodeCollection[index].Nodes.Count - 1].ContextMenuStrip = reflexiveMenu;
//Add the TagBlockArray object (reflexive) to the Tag to let us edit it directly from the node
treeNodeCollection[index].Nodes[treeNodeCollection[index].Nodes.Count - 1].Tag = val;
//TagBlocks also might be null, dealio
if ((val as TagBlockArray).TagBlocks == null) continue;
foreach (TagBlock tagBlock in (val as TagBlockArray).TagBlocks)
{
//Recurse
LoadTagBlockValuesAsNodes(treeNodeCollection[index].Nodes[treeNodeCollection[index].Nodes.Count - 1].Nodes, tagBlock);
}
}
}
}
/// <summary>
/// Performs an update on the node.
/// This updates the tag block, information, and label.
/// </summary>
public void Update()
{
//Prepare
block = TagBlock.Zero;
//Check
if (DataObject.Value != null)
{
block = (TagBlock)DataObject.Value;
}
//Setup
if (block.Count == 0)
{
ForeColor = SystemColors.GrayText; Text = DataObject.Node.Name;
}
else
{
ForeColor = Color.Black; Text = $"{dataObject.Node.Name} [{SelectedIndex + 1}/{block.Count}]";
}
//Loop
foreach (TagDataNode node in Nodes)
{
node.Update();
}
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
private void LoadTreeView(XmlNode parentnode, TagBlock workingTagblock)
{
treeView1.Nodes.Clear();
TagHeaderTreeNode node = new TagHeaderTreeNode(workingTagblock.Name, parentnode, workingTagblock);
treeView1.Nodes.Add(node);
LoadTreeView(parentnode, workingTagblock, treeView1.Nodes[0]);
treeView1.SelectedNode = treeView1.TopNode;
treeView1.TopNode.Expand();
}
private void cmdLoadTagBlock_Click(object sender, EventArgs e)
{
if (Loaded)
{
//Create new TagBlock object from Tag object
TagBlock = TagBlock.CreateFromTag(Tag);
DisplayTagBlockInTreeView();
}
}
public override void Write(IO.EndianWriter stream)
{
const int k_alignment = Compiler.kDefaultAlignment;
int align;
using (var mem = InitializeMemoryStream())
{
DynamicTagGroups.Write(MemoryStream); // write the data array to the stream
MemoryStream.Write((int)0); MemoryStream.Write((int)0); // alignment
StringPoolToMemoryStream();
Import import = OwnerState.Importer as Import;
FixupsToMemoryStream();
ScriptingToStream(import);
EnumerationsToMemoryStream();
TagReferencesToMemoryStream();
TagDataToMemoryStream();
#region TagBlock
TagBlock tb = new TagBlock();
foreach (Import.TagBlock tagb in import.Blocks.Values)
{
tb.Reset(tagb);
tb.Write(MemoryStream);
}
#endregion
#region TagGroup
TagGroup tg = new TagGroup();
foreach (Import.TagGroup tagg in import.Groups.Values)
{
tg.Reset(tagg);
tg.Write(MemoryStream);
}
#endregion
PostprocessWritebacks();
// Create header
PostprocessHeaderThenStream(stream, CalculateStringPoolBaseAddress());
mem.WriteTo(stream.BaseStream); // write all the data that will be read into memory from a tool to the file
}
align = k_alignment - (stream.Length % k_alignment);
if (align != k_alignment)
{
stream.Write(new byte[align]);
}
}
public void AddTagBlock(TagBlock block)
{
block.Position.X += this.OffsetX;
block.Position.Y += this.Height;
this.tagBlocks.Add(block);
this.Width = Math.Max(this.Width, block.Width);
this.Height += block.Height;
}
public Struct(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttribute("groupTag", ref groupTag);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttributeOpt("isIncludedInTagGroupsChecksum", ref IsIncludedInTagGroupsChecksum);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public void LoadTag(Tag tag)
{
HaloTag = tag;
workingTagblock = TagBlock.CreateInstance(tag.Type);
workingTagblock.Deserialize(tag.TagStream, 0, 0);
Enabled = false;
XmlDocument xDoc = new XmlDocument();
xDoc.Load(System.IO.Path.GetDirectoryName(Application.ExecutablePath) + string.Format(@"./MetaLayouts/{0}.xml", new Sunfish.ValueTypes.TagType(tag.Type).ToPathSafeString()));
LoadTreeView(xDoc.LastChild.LastChild, workingTagblock);
Enabled = true;
loaded = true;
}
/// <summary>
/// Generates an opening script tag. Can be used within a "using" block and the tag will auto-close.
/// </summary>
/// <param name="helper">The HTML helper instance that this method extends.</param>
/// <param name="defer">Whether or not to defer script execution until after page load completion.</param>
/// <returns></returns>
public static TagBlock BeginJSBlock(this HtmlHelper helper, bool defer)
{
var tag = new TagBlock(helper.ViewContext, "script");
tag.AddAttribute("type", "text/javascript");
if (defer)
{
tag.AddAttribute("defer", "defer");
}
tag.OpenBlock();
return(tag);
}
/// <summary>
/// Writes out an opening style tag for inline Css. Can be used within a using() block for auto-close closure.
/// </summary>
/// <param name="helper">The HTML helper instance that this method extends.</param>
/// <param name="media">Css media type.</param>
/// <returns></returns>
public static TagBlock BeginCssBlock(this HtmlHelper helper, string media)
{
var tag = new TagBlock(helper.ViewContext, "style");
tag.AddAttribute("type", "text/css");
if (media != null)
{
tag.AddAttribute("media", media);
}
tag.AddAttribute("type", "text/css");
tag.OpenBlock();
return(tag);
}
void IMetadataStream.ResizeTagBlock(EndianWriterEx writer, ref TagBlock block, int entrySize, int newCount)
{
if (newCount == block.Count)
{
return;
}
var sourceAddress = (int)block.Pointer.Address;
var sourceSize = entrySize * block.Count;
var newSize = entrySize * newCount;
if (newCount < block.Count)
{
block = new TagBlock(newCount, block.Pointer);
tracker.Release(sourceAddress + newSize, sourceSize - newSize);
return;
}
//release before find, in case the release creates a bigger contiguous chunk
tracker.Release(sourceAddress, sourceSize);
int newAddress;
if (!tracker.Find(newSize, out newAddress))
{
//if there isnt space then make some
int freeStart, freeCount;
segmenter.AddMetadata(writer, newSize, out freeStart, out freeCount);
ShiftAllocations(freeCount);
tracker.Insert(freeStart, freeCount);
if (!tracker.Find(newSize, out newAddress)) //should always return true
{
throw new InvalidDataException("Could not find free space after expanding map!");
}
}
var translator = SourceItem.CacheFile.DefaultAddressTranslator;
var expander = (SourceItem.CacheFile as IMccCacheFile)?.PointerExpander;
var newPointer = translator.GetPointer(newAddress);
if (expander != null)
{
newPointer = expander.Contract(newPointer);
}
block = new TagBlock(newCount, new Pointer((int)newPointer, block.Pointer));
tracker.Allocate(newAddress, newSize);
}
public override void Write(IO.EndianWriter stream)
{
Compiler comp = stream.Owner as Compiler;
TagBlock tb = new TagBlock((Import.TagBlock)tagStruct.Block);
tb.Write(stream);
comp.MarkLocationFixup(tagStruct.Name, stream, false);
stream.Write(tagStruct.Name);
stream.WriteTag(tagStruct.GroupTag);
stream.Write(tagStruct.Block.DisplayName);
stream.WritePointer(tb.RuntimeAddress);
}
void UpdateTagBlocks(Cairo.Context cr, Image image, double offsetY, double paddingBottom)
{
this.tagBlockColumns.Clear();
this.tagBlockSiteColumn.Clear();
if (image == null)
{
return;
}
cr.SelectTagOverlayFont();
var column = new TagBlockColumn(8.0);
foreach (string tag in image.Tags)
{
var tagBlock = new TagBlock(cr, tag);
tagBlock.Position.Y = offsetY;
if (tagBlock.IsSiteTag)
{
this.tagBlockSiteColumn.AddTagBlock(tagBlock);
}
else
{
if (tagBlock.Height + column.Height + offsetY > this.canvasSize.Y - paddingBottom)
{
if (column.Count == 0)
{
// height is too small to fit even a single item
break;
}
this.tagBlockColumns.Add(column);
column = new TagBlockColumn(column.OffsetX + column.Width);
}
column.AddTagBlock(tagBlock);
}
}
if (column.Count > 0)
{
this.tagBlockColumns.Add(column);
}
this.tagBlockSiteColumn.Move(this.canvasSize.X - 8);
}
public TagWrapper(TagBlock tag, MapStream map, Tag meta)
{
tag_ = tag;
/* Enumerate through all the StringIDs in this tag, check to see if they exist in the Globals list,
* if not we should add them locally and update the StringID value to point to the list*/
foreach (StringID string_id in tag as IEnumerable<StringID>)
{
if (Halo2.Strings.Contains(string_id)) continue;
else
{
var string_value = map.Strings[string_id.Index];
var entry = new KeyValuePair<StringID, string>(string_id, string_value);
local_strings_.Add(entry);
var index = local_strings_.IndexOf(entry);
short string_id_index = (short)(index |= 0x8000);
sbyte string_length = (sbyte)Encoding.UTF8.GetByteCount(string_value);
var bytes = BitConverter.GetBytes((int)new StringID(string_id_index, string_length));
//((IField)string_id).SetFieldData(bytes);
throw new Exception();
}
}
foreach (TagIdent tag_id in tag as IEnumerable<TagIdent>)
{
tag_ids_.Add(tag_id);
}
/*Intent: to build a list of all tagblock addresses in tag
*/
foreach (var array in tag as IEnumerable<IFieldArray>)
{
var address = array.Address;
if (array.Fields.Count() > 0)
{
var item = new { Address = address, Size = array.Fields[0].Size, Count = array.Fields.Count() };
tag_blocks.Add(item);
if (meta.Contains(item.Address))
{
}
}
}
/* Intent: check every tag_block in the list for being external
* if it is external build a reference list and add information about the tag_block
* to that list.
* address => [count, size]?
* */
}
void ProcessTagBlocks(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagBlock")
{
continue;
}
s.SaveCursor(n);
var block = new TagBlock(state, s);
s.RestoreCursor();
string name_str = block.ToString();
try { Blocks.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag block definition", name_str); }
}
}
private TagBlock TagBlock(TagBlock tagBlock, int memberId, string Url, string ImageUrl, string tagType, string siteTitle)
{
TagBlock block;
if (tagBlock == null)
{
block = new TagBlock();
}
else
{
block = tagBlock;
}
block.MemberId = memberId;
block.Url = Url;
block.SiteImageUrl = ImageUrl;
block.TagType = tagType;
block.SiteTitle = siteTitle;
return(block);
}
/// <summary>
/// Wraps a data object using the supplied offset.
/// </summary>
/// <param name="dataObject">The base offset.</param>
public void Wrap(DataObject dataObject, uint offset)
{
//Check
if (offset == 0)
{
dataObject.Reset(); return;
}
//Set address
dataObject.BaseAddress = offset;
dataObject.Address = (uint)(offset + dataObject.Node.FieldOffset);
dataObject.ReadValue();
//Check
if (dataObject.IsTagBlock)
{
//Get Block
TagBlock block = (TagBlock)dataObject.Value;
uint childOffset = 0;
//Get Block Offset
int blockOffset = dataObject.Node.Length * dataObject.SelectedIndex;
if (block.Offset > 0)
{
childOffset = (uint)(block.Offset + blockOffset);
}
//Loop
foreach (DataObject childObject in dataObject)
{
Wrap(childObject, childOffset);
if (childObject.SelectedIndex >= block.Count)
{
childObject.SelectedIndex = 0;
}
}
}
}
public static unic CollapseUnicode(unic unicodeTagblock, UnicodeTable dataSource)
{
unic unic = new unic(true);
TagBlockArray array = unic.Values[0] as TagBlockArray;
unic.Data = new byte[16];
MemoryStream ms = new MemoryStream(unicodeTagblock.Data);
BinaryReader reader = new BinaryReader(ms);
ms.Position = 16;
int offset = reader.ReadInt16();
int count = reader.ReadInt16();
TagBlock[] tagBlocks = new TagBlock[count];
TagBlockArray tagBlockArray = unic.Values[0] as TagBlockArray;
for (int i = 0; i < count; i++)
tagBlocks[i] = (TagBlock)Activator.CreateInstance(array.TagBlockType);
List<byte> unicodeBytes = new List<byte>();
for (int i = 0; i < count; i++)
{
byte[] buffer = new byte[48];
MemoryStream blockStream = new MemoryStream(buffer);
using (blockStream)
{
BinaryWriter bw = new BinaryWriter(blockStream);
blockStream.Position = 0;
bw.Write(dataSource[offset + i].StringReference);
bw.Write(unicodeBytes.Count);
}
tagBlocks[i].Data = buffer;
unicodeBytes.AddRange(Encoding.UTF8.GetBytes(dataSource[offset + i].Value));
unicodeBytes.Add((byte)0x00);
}
array.TagBlocks = tagBlocks;
(unic.Values[1] as ByteArray).Length = unicodeBytes.Count;
(unic.Values[1] as ByteArray).Data = unicodeBytes.ToArray();
return unic;
}
public void FindAllTagsTest()
{
using (var scope = new TransactionScope())
{
List <Tag> tagList = new List <Tag>
{
CreateTag(tagName1),
CreateTag(tagName2)
};
TagBlock tagFoundList = productService.FindAllTags();
// Check data
Assert.AreEqual(tagList.Count, tagFoundList.Tags.Count);
for (int i = 0; i < tagList.Count; i++)
{
Assert.AreEqual(tagList[i].tagId, tagFoundList.Tags[i].tagId);
Assert.AreEqual(tagList[i].tagName, tagFoundList.Tags[i].tagName);
}
Assert.IsFalse(tagFoundList.ExistMoreTags);
}
}
/// <summary>
/// Parses the TagBlock, which updates the TagBlock internal 'pointers',
/// then copies it to the stream and the current stream location.
/// Note: the tag-block will be parsed so that the internal pointers are stream-offset values
/// </summary>
/// <param name="source">TagBlock object which to perform parsing on and copying from</param>
/// <param name="stream">Destination stream for copied data</param>
/// <returns>true</returns>
public static bool Map(TagBlock source, Stream stream)
{
/* Intent: Using the TagBlock which is passed in, calculate all Pointers—count and address—
* values for the new position in the stream. Copy all the bytes from the TagBlocks
* recursively into the stream. */
var start_offset = stream.Position; /* Store the current position in the stream that was passed in.
* This will be the address we start copying TagBlock data at */
var block_size = (source as IPointable).SizeOf; // Size of the source TagBlock internal data
stream.Write(Padding.GetBytes(block_size, 0xCD), 0, block_size); /* Write padding bytes for debug purposes. This also moves the
* streams internal position forward so that we are 'reserving'
* this space*/
(source as IPointable).CopyTo(stream); /* This method is a recursive two-pass into the TagBlock which
* will update internal properties before copying to the stream */
stream.Position = start_offset; // Move the stream back to our stored offset
stream.Write(source.GetMemory().ToArray(), 0, block_size); // Write the TagBlock internal memory to the stream
return true;
}
public override void Write(IO.EndianWriter stream)
{
const int k_alignment = Compiler.kDefaultAlignment;
int align;
using (var mem = InitializeMemoryStream())
{
DynamicTagGroups.Write(MemoryStream); // write the data array to the stream
MemoryStream.Write((int)0); MemoryStream.Write((int)0); // alignment
StringPoolToMemoryStream();
Import import = OwnerState.Importer as Import;
FixupsToMemoryStream();
ScriptingToStream(import);
EnumerationsToMemoryStream();
TagReferencesToMemoryStream();
TagDataToMemoryStream();
#region TagBlock
TagBlock tb = new TagBlock();
foreach (Import.TagBlock tagb in import.Blocks.Values)
{
tb.Reset(tagb);
tb.Write(MemoryStream);
}
#endregion
#region TagGroup
TagGroup tg = new TagGroup();
foreach (Import.TagGroup tagg in import.Groups.Values)
{
tg.Reset(tagg);
tg.Write(MemoryStream);
}
#endregion
PostprocessWritebacks();
// Create header
PostprocessHeaderThenStream(stream, CalculateStringPoolBaseAddress());
mem.WriteTo(stream.BaseStream); // write all the data that will be read into memory from a tool to the file
}
align = k_alignment - (stream.Length % k_alignment);
if (align != k_alignment) stream.Write(new byte[align]);
}
public HaloMap(string path)
{
BinaryReader reader;
reader = new BinaryReader(File.Open(path, FileMode.Open));
string integrity = System.Text.Encoding.UTF8.GetString(reader.ReadBytes(4));
reader.BaseStream.Seek(0, SeekOrigin.End);
detectedBytes = reader.BaseStream.Position;
isBigEndian = integrity.Equals("head");
if (isBigEndian)
{
//switch to BigEndian
reader.Close();
reader = new BigEndianReader(File.Open(path, FileMode.Open));
}
else if (!integrity.Equals("daeh"))
{
Debug.LogError("Header Integrity failed! Found:" + integrity);
return;
}
reader.BaseStream.Seek(0, SeekOrigin.Begin);
header = new Header(reader);
reader.BaseStream.Seek(0, SeekOrigin.Begin);
reader.ScanUntilFound(1952540531);
scanForTagsFoundAt = reader.BaseStream.Position - 36;
if (header.tagDataOffset > detectedBytes)
{
Debug.LogWarning("EOF for tagOffset. Using scanned offset");
reader.BaseStream.Seek(scanForTagsFoundAt, SeekOrigin.Begin);
//Debug.LogFormat("Found sgat at:"+reader.BaseStream.Position+"(0x"+(reader.BaseStream.Position-header.tagDataOffset).ToString("X")+" offset)");
}
else
{
reader.BaseStream.Seek(header.tagDataOffset, SeekOrigin.Begin);
}
long tagArrayLocation = reader.BaseStream.Position;
tagBlock = new TagBlock(reader, header.gameEngine);
tagArrayLocation += ((UInt16)tagBlock.TagArrayPointer);
Debug.Log("Parsed TagBlock. " + tagArrayLocation.ToString("X"));
reader.BaseStream.Seek(tagArrayLocation, SeekOrigin.Begin);
Debug.Log("Beginning parse");
tags = new List <Tag>();
try{
for (int i = 0; i < tagBlock.TagCount; i++)
{
tags.Add(new Tag(reader, (0x10000) + header.tagDataOffset));
}
}catch (EndOfStreamException e) {
Debug.LogError("Couldn't parse tags. Invalid offset. Purging tags for safety.");
tags.Clear();
}
//Debug.Log("NextString:0x"+reader.BaseStream.Position.ToString("X"));
//Debug.Log("Offset from Tagblock:0x"+(reader.BaseStream.Position-header.tagDataOffset).ToString("X"));
//nextString=reader.ReadCString();
//reader.BaseStream.Seek(header.tagDataOffset,SeekOrigin.Begin);
//tagBlock.tagsIntegrity=reader.ReadUTF8String(4);
//
reader.Close();
reader = null;
}
protected override void ProcessDefinition(XmlNode node, BlamLib.CheApe.ProjectState state, BlamLib.IO.XmlStream s)
{
StringIdFieldsInitialize(state);
string name_str;
switch (node.Name)
{
#region Tag Structs
case "structs":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "Struct")
{
continue;
}
s.SaveCursor(n);
TagStruct block = new TagStruct(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Structs.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag struct definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Blocks
case "blocks":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagBlock")
{
continue;
}
s.SaveCursor(n);
TagBlock block = new TagBlock(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Blocks.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag block definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Groups
case "groups":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagGroup")
{
continue;
}
s.SaveCursor(n);
TagGroup group = new TagGroup(state, s);
s.RestoreCursor();
name_str = group.ToString();
try { Groups.Add(name_str, group); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag group definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
}
}
private void structureView_AfterSelect(object sender, TreeViewEventArgs e)
{
//Prepare
tagBlockIndexToolStripComboBox.Visible = false;
TagBlock block = TagBlock.Zero;
TagDataNode dataNode = null;
//Clear
tagBlockIndexToolStripComboBox.Items.Clear();
//Check
if (e.Node is TagDataNode)
{
//Get Node
dataNode = (TagDataNode)e.Node;
//Check
if (dataNode.DataObject.IsValid && dataNode.DataObject.Value != null)
{
//Build Html
tagEditor_BuildHtml(dataNode.DataObject);
//Get block
block = (TagBlock)dataNode.DataObject.Value;
//Get Names
string[] names = dataNode.DataObject.GetDisplayNames(Map);
//Loop
for (int i = 0; i < block.Count; i++)
{
tagBlockIndexToolStripComboBox.Items.Add($"{i}: {names[i]}");
}
//Select
if (block.Count > dataNode.SelectedIndex)
{
tagBlockIndexToolStripComboBox.SelectedIndex = dataNode.SelectedIndex;
}
//Set
tagBlockIndexToolStripComboBox.Visible = block.Count > 0;
}
}
else
{
//Build Html
tagEditor_BuildHtml(wrapper);
//Set
dataObjects = wrapper;
//Add event listener, or just call set values.
if (tagDataWebBrowser.ReadyState == WebBrowserReadyState.Loading || tagDataWebBrowser.IsBusy)
{
tagDataWebBrowser.DocumentCompleted += tagDataWebBrowser_DocumentCompleted;
}
else
{
tagEditor_SetValues(wrapper);
}
}
}
private void LoadTreeView(XmlNode parentnode, TagBlock workingTagblock, TreeNode node)
{
int offset = 0;
foreach (XmlNode childnode in parentnode)
{
if (childnode.NodeType == XmlNodeType.Element)
{
switch (childnode.Name.ToLower())
{
case "tagblock":
if (workingTagblock.Values == null) { return; }
foreach (Value value in workingTagblock.Values)
{
if (value.Offset == offset && value is TagBlockArray && (value as TagBlockArray).Length > 0)
{
TagStructArrayTreeNode treenode = new TagStructArrayTreeNode(childnode.Attributes["name"].Value, childnode);
for (int i = 0; i < (value as TagBlockArray).Length; i++)
{
TagStructTreeNode childtreenode = new TagStructTreeNode(string.Format("chunk:{0}", i), (value as TagBlockArray).TagBlocks[i]);
LoadTreeView(childnode, (value as TagBlockArray).TagBlocks[i], childtreenode);
treenode.Nodes.Add(childtreenode);
}
node.Nodes.Add(treenode);
break;
}
}
offset += 8;
break;
case "taginstance":
offset += 8;
break;
case "tagclass":
offset += 4;
break;
case "tagindex":
offset += 4;
break;
case "stringid":
offset += 4;
break;
case "string":
offset += int.Parse(childnode.Attributes["byte-length"].Value);
break;
case "unused":
offset += int.Parse(childnode.Attributes["length"].Value);
break;
case "byte":
offset += sizeof(byte);
break;
case "short":
offset += sizeof(short);
break;
case "ushort":
offset += sizeof(ushort);
break;
case "int":
offset += sizeof(int);
break;
case "uint":
offset += sizeof(uint);
break;
case "float":
case "single":
offset += sizeof(float);
break;
case "enum":
switch (childnode.Attributes["base"].Value)
{
case "byte":
offset += sizeof(byte);
break;
case "short":
offset += sizeof(short);
break;
case "int":
offset += sizeof(int);
break;
}
break;
case "flags":
switch (childnode.Attributes["base"].Value)
{
case "byte":
offset += sizeof(byte);
break;
case "short":
offset += sizeof(short);
break;
case "int":
offset += sizeof(int);
break;
}
break;
default:
{ }
break;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="tagBlock"></param>
public static void WriteTagBlock(this BinaryWriter writer, TagBlock tagBlock)
{
writer.Write(tagBlock);
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
void LoadValues(TagBlock tagBlock, int startIndex, int count)
{
int offset;
for (int i = startIndex; i < startIndex + count; i++)
{
try
{
if (dataGridView.Rows[i] is Row) { (dataGridView.Rows[i] as Row).Data = tagBlock.Data; }
offset = (dataGridView.Rows[i] as Row).Offset;
if (dataGridView.Rows[i] is StringRow)
dataGridView.Rows[i].Cells[2].Value = (dataGridView.Rows[i] as StringRow).Encoding.GetString(tagBlock.Data, offset, (dataGridView.Rows[i] as StringRow).Length).Trim(char.MinValue);
else if (dataGridView.Rows[i] is StringIdRow)
{
Sunfish.ValueTypes.StringId sid = BitConverter.ToInt32(tagBlock.Data, offset);
(dataGridView.Rows[i] as StringIdRow).Value = HaloTag.Strings[sid.Index];
}
else if (dataGridView.Rows[i] is TagDialogRow)
{
Sunfish.ValueTypes.TagType type = new Sunfish.ValueTypes.TagType(new byte[] { tagBlock.Data[offset], tagBlock.Data[offset + 1], tagBlock.Data[offset + 2], tagBlock.Data[offset + 3] });
Sunfish.ValueTypes.TagIndex index = BitConverter.ToInt32(tagBlock.Data, offset + 4);
(dataGridView.Rows[i] as TagDialogRow).Value = HaloTag.TagReferences[index.Index];
}
else if (dataGridView.Rows[i] is Row)
{
//Load byte
if (dataGridView.Rows[i].Cells[2].ValueType == typeof(byte))
dataGridView.Rows[i].Cells[2].Value = tagBlock.Data[offset];
//Load short
else if (dataGridView.Rows[i].Cells[2].ValueType == typeof(short))
dataGridView.Rows[i].Cells[2].Value = BitConverter.ToInt16(tagBlock.Data, offset);
//Load ushort
else if (dataGridView.Rows[i].Cells[2].ValueType == typeof(ushort))
dataGridView.Rows[i].Cells[2].Value = BitConverter.ToUInt16(tagBlock.Data, offset);
//Load int
else if (dataGridView.Rows[i].Cells[2].ValueType == typeof(int))
dataGridView.Rows[i].Cells[2].Value = BitConverter.ToInt32(tagBlock.Data, offset);
//Load uint
else if (dataGridView.Rows[i].Cells[2].ValueType == typeof(uint))
dataGridView.Rows[i].Cells[2].Value = BitConverter.ToUInt32(tagBlock.Data, offset);
//Load float
else if (dataGridView.Rows[i].Cells[2].ValueType == typeof(float))
dataGridView.Rows[i].Cells[2].Value = BitConverter.ToSingle(tagBlock.Data, offset);
else DisableRows(i, 1);
}
else DisableRows(i, 1);
}
catch { continue; }
}
}
/// <summary>
/// The button 1_ click.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
/// <remarks></remarks>
private void button1_Click(object sender, EventArgs e)
{
ControlSwapper parent = (ControlSwapper)this.Parent.Parent.Parent;
// Add selected control
IFPIO.Option[] options = null;
//int strLength = 0;
Control con = null;
switch (((dataTypeStruct)comboBox1.SelectedItem).name.ToLower())
{
/*
parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Byte, parent.lineNum));
parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Short, parent.lineNum));
parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Int, parent.lineNum));
parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Float, parent.lineNum));
*/
case "byte":
case "short":
case "ushort":
case "int":
case "uint":
case "float":
case "unknown":
case "unused":
con = new DataValues(
parent.name,
null,
parent.chunkoffset,
(IFPIO.ObjectEnum)
Enum.Parse(typeof(IFPIO.ObjectEnum), ((dataTypeStruct)comboBox1.SelectedItem).name, true),
parent.lineNum);
break;
case "char_enum":
case "enum":
case "long_enum":
options = new IFPIO.Option[((dataTypeStruct)comboBox1.SelectedItem).size << 3];
// Size * 8 bits
for (int x = 0; x < options.Length; x++)
{
options[x] = new IFPIO.Option("Bit " + x, x.ToString(), parent.lineNum);
}
if (parent.splitContainer1.Panel1.Controls[0] is Bitmask)
{
Bitmask b = (Bitmask)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in b.Options)
{
if (o.value < options.Length)
{
options[o.value].name = o.name;
}
}
}
;
if (parent.splitContainer1.Panel1.Controls[0] is Enums)
{
Enums en = (Enums)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in en.Options)
{
if (o.value < options.Length)
{
options[o.value].name = o.name;
}
}
}
;
con = new Enums(parent.name, null, parent.chunkoffset, options.Length, options, parent.lineNum);
break;
case "byte_flags":
case "word_flags":
case "long_flags":
options = new IFPIO.Option[((dataTypeStruct)comboBox1.SelectedItem).size << 3];
// Size * 8 bits
for (int x = 0; x < options.Length; x++)
{
options[x] = new IFPIO.Option("Bit " + x, x.ToString(), parent.lineNum);
}
if (parent.splitContainer1.Panel1.Controls[0] is Bitmask)
{
Bitmask b = (Bitmask)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in b.Options)
{
options[o.value].name = o.name;
}
}
;
if (parent.splitContainer1.Panel1.Controls[0] is Enums)
{
Enums en = (Enums)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in en.Options)
{
options[o.value].name = o.name;
}
}
;
con = new Bitmask(
parent.name, null, parent.chunkoffset, options.Length, options, parent.lineNum);
break;
case "stringid":
con = new SID(parent.name, null, parent.chunkoffset, parent.lineNum);
break;
case "string":
con = new EntStrings(
parent.name,
null,
parent.chunkoffset,
((dataTypeStruct)comboBox1.SelectedItem).size,
false,
parent.lineNum);
break;
case "unicodestring":
con = new EntStrings(
parent.name,
null,
parent.chunkoffset,
((dataTypeStruct)comboBox1.SelectedItem).size,
true,
parent.lineNum);
break;
case "block":
con = new TagBlock(parent.name, null, parent.chunkoffset, parent.lineNum);
break;
case "ident":
con = new Ident(parent.name, null, parent.chunkoffset, true, parent.lineNum);
break;
case "struct":
// Unhandled
//int ifkdn = 0;
break;
default:
{
return;
}
}
Button but = new Button();
but.Dock = DockStyle.Right;
but.Size = new Size(30, 30);
but.Text = "-";
but.Click += but_Click;
if (con != null)
{
con.Controls.Add(but);
// con.Enabled = false;
con.Dock = DockStyle.Top;
Point loc = con.Controls[con.Controls.Count - 2].Location;
loc.X -= 50;
con.Controls[con.Controls.Count - 2].Location = loc;
// con.TabIndex--;
parent.splitContainer1.Panel2.Controls.Add(con);
con.BringToFront();
((ControlSwapper)this.TopLevelControl).newControlSize +=
((ControlSwapper)this.TopLevelControl).getSizeOf(((dataTypeStruct)comboBox1.SelectedItem).name);
if (((ControlSwapper)this.TopLevelControl).label1.Text.Contains(" :: "))
{
((ControlSwapper)this.TopLevelControl).label1.Text =
((ControlSwapper)this.TopLevelControl).label1.Text.Remove(
((ControlSwapper)this.TopLevelControl).label1.Text.IndexOf(" :: "));
}
((ControlSwapper)this.TopLevelControl).label1.Text += " :: New Control Size : " +
((ControlSwapper)this.TopLevelControl).
newControlSize;
}
parent.splitContainer1.Panel2.Controls[parent.splitContainer1.Panel2.Controls.IndexOf(this)].
BringToFront();
parent.splitContainer1.Panel2.Controls[parent.splitContainer1.Panel2.Controls.IndexOf(this)].TabIndex++;
}
public override void Write(IO.EndianWriter stream)
{
Compiler comp = stream.Owner as Compiler;
TagBlock tb = new TagBlock((Import.TagBlock)tagStruct.Block);
tb.Write(stream);
comp.MarkLocationFixup(tagStruct.Name, stream, false);
stream.Write(tagStruct.Name);
stream.WriteTag(tagStruct.GroupTag);
stream.Write(tagStruct.Block.DisplayName);
stream.WritePointer(tb.RuntimeAddress);
}
public override void Write(IO.EndianWriter stream)
{
Compiler comp = stream.Owner as Compiler;
TagBlock tb = new TagBlock((Import.TagBlock)tagGroup.Block);
tb.Write(stream);
comp.MarkLocationFixup(tagGroup.Name, stream, false);
stream.Write(tagGroup.Name);
stream.Write((int)0);
stream.WriteTag(tagGroup.GroupTag);
if (tagGroup.ParentTag != null)
stream.WriteTag(tagGroup.ParentTag);
else
stream.Write((int)-1);
stream.Write(tagGroup.Version);
stream.Write((short)1); // init'd
stream.Write((int)0);
stream.Write((int)0);
stream.Write((int)0);
stream.Write((int)0);
stream.WritePointer(tb.RuntimeAddress);
for (int x = 0; x < 17; x++) stream.Write((int)0); // child group tags
stream.Write((int)0); // we don't support that shit, gtfo
stream.Write(comp.Strings.GetNull());
}
private void tagEditor_BuildHtml(IEnumerable <DataObject> dataObjects)
{
//Prepare
TagBlock block = TagBlock.Zero;
StringBuilder options = null;
string typeLabel = null;
formatter.Clear();
//Loop
foreach (DataObject dataObject in dataObjects)
{
if (!dataObject.IsValid)
{
continue;
}
typeLabel = Enum.GetName(typeof(IfpNodeType), dataObject.Node.Type);
//Get block level
if (!string.IsNullOrEmpty(dataObject.Node.Layer))
{
//Prepare
options = new StringBuilder();
options.AppendLine(TagDataFormatter.CreateOption(-1, "Null"));
switch (dataObject.Node.Layer)
{
case "root":
dataObject.DataStream.Seek(SelectedEntry.PostProcessedOffset + dataObject.Node.TagBlockOffset, SeekOrigin.Begin);
using (BinaryReader reader = dataObject.DataStream.CreateReader())
block = (TagBlock)reader.ReadInt64();
for (int i = 0; i < block.Count; i++)
{
options.AppendLine(TagDataFormatter.CreateOption(i, $"{i}: {value_GetLabel(dataObject.Node.ItemType, dataObject.DataStream, block.Offset + (dataObject.Node.TagBlockSize * i) + dataObject.Node.ItemOffset)}"));
}
formatter.AddBlockSelect(dataObject.UniqueId, typeLabel, options.ToString(), dataObject.Node.Name);
break;
default:
break;
}
}
else
{
switch (dataObject.Node.Type)
{
case IfpNodeType.Byte:
case IfpNodeType.SignedByte:
case IfpNodeType.Short:
case IfpNodeType.UnsignedShort:
case IfpNodeType.Int:
case IfpNodeType.UnsignedInt:
case IfpNodeType.Long:
case IfpNodeType.UnsignedLong:
case IfpNodeType.Single:
case IfpNodeType.Double:
formatter.AddValue(dataObject.UniqueId, typeLabel, dataObject.Node.Name);
break;
case IfpNodeType.Enumerator8:
case IfpNodeType.Enumerator16:
case IfpNodeType.Enumerator32:
case IfpNodeType.Enumerator64:
options = new StringBuilder();
foreach (IfpNode option in dataObject.Node.Nodes)
{
options.AppendLine(TagDataFormatter.CreateOption(option.Value, option.Name));
}
formatter.AddEnum(dataObject.UniqueId, typeLabel, options.ToString(), dataObject.Node.Name);
break;
case IfpNodeType.Bitfield8: formatter.AddBitField(dataObject.UniqueId, typeLabel, 8, dataObject.Node.Name); break;
case IfpNodeType.Bitfield16: formatter.AddBitField(dataObject.UniqueId, typeLabel, 16, dataObject.Node.Name); break;
case IfpNodeType.Bitfield32: formatter.AddBitField(dataObject.UniqueId, typeLabel, 32, dataObject.Node.Name); break;
case IfpNodeType.Bitfield64: formatter.AddBitField(dataObject.UniqueId, typeLabel, 64, dataObject.Node.Name); break;
case IfpNodeType.String32: formatter.AddString(dataObject.UniqueId, 32, typeLabel, dataObject.Node.Name); break;
case IfpNodeType.String64: formatter.AddString(dataObject.UniqueId, 64, typeLabel, dataObject.Node.Name); break;
case IfpNodeType.Unicode128: formatter.AddString(dataObject.UniqueId, 128, typeLabel, dataObject.Node.Name); break;
case IfpNodeType.Unicode256: formatter.AddString(dataObject.UniqueId, 256, typeLabel, dataObject.Node.Name); break;
case IfpNodeType.TagId: formatter.AddTagId(dataObject.UniqueId, typeLabel, dataObject.Node.Name); break;
case IfpNodeType.StringId: formatter.AddStringId(dataObject.UniqueId, typeLabel, dataObject.Node.Name); break;
}
}
}
//Set
tagDataWebBrowser.DocumentText = formatter.GetHtml();
}
/// <summary>
/// Constructs a tag group definition from an xml definition node
/// </summary>
/// <param name="state"></param>
/// <param name="s"></param>
public TagGroup(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttributeOpt("isIncludedInTagGroupsChecksum", ref IsIncludedInTagGroupsChecksum);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = blockName = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public TagHeaderTreeNode(string name, XmlNode node, TagBlock tagblock)
: base(name)
{
Values = node;
TagBlock = tagblock;
}
public Struct(BlamLib.CheApe.ProjectState state, IO.XmlStream s) : base(state, s)
{
s.ReadAttribute("groupTag", ref groupTag);
block = new TagBlock();
block.DisplayName = name;
string tempName = nameString + "_block";
block.Name = state.Compiler.Strings.Add(tempName);
block.Read(state, s);
}
public TagStructTreeNode(string name, TagBlock tagblock) : base(name) { TagBlock = tagblock; }
void ProcessTagBlocks(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagBlock") continue;
s.SaveCursor(n);
var block = new TagBlock(state, s);
s.RestoreCursor();
string name_str = block.ToString();
try { Blocks.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag block definition", name_str); }
}
}
public InMemoryBlockCollection(IMetadataStream stream, EndianReader reader, XmlNode node, InMemoryBlockCollection parent, int parentBlockIndex)
{
this.stream = stream;
defaultValues = new Dictionary <int, byte[]>();
XmlNode = node;
ParentBlock = parent;
ParentEntryIndex = parentBlockIndex;
ChildBlocks = new List <InMemoryBlockCollection>();
ParentBlock?.ChildBlocks.Add(this);
if (parent == null) //tag root
{
Name = stream.SourceTag.FileName();
blockRef = null;
EntryCount = 1;
EntrySize = node.GetIntAttribute("baseSize") ?? 0;
data = reader.ReadBytes(VirtualSize);
}
else
{
offsetInParent = node.GetIntAttribute("offset") ?? 0;
Name = node.GetStringAttribute("name");
blockRef = reader.ReadObject <TagBlock>();
EntryCount = BlockRef.IsInvalid ? 0 : BlockRef.Count;
EntrySize = node.GetIntAttribute("elementSize", "entrySize", "size") ?? 0;
if (EntryCount > 0)
{
reader.Seek(BlockRef.Pointer.Address, SeekOrigin.Begin);
data = reader.ReadBytes(VirtualSize);
}
else
{
data = Array.Empty <byte>();
}
}
foreach (var element in node.SelectNodes("*[@offset][@defaultValue]").OfType <XmlNode>())
{
var offset = element.GetIntAttribute("offset").Value;
var defaultValue = element.GetStringAttribute("defaultValue");
Func <string, int> getFlagValue = (val) => val.Split('|').Select(s => 1 << int.Parse(s)).Sum();
byte[] bytes;
switch (element.Name.ToLower())
{
case "int8":
case "enum8":
case "blockindex8":
bytes = new[] { defaultValue == "-1" ? byte.MaxValue : byte.Parse(defaultValue) };
break;
case "int16":
case "blockindex16":
bytes = BitConverter.GetBytes(short.Parse(defaultValue));
break;
case "uint16":
case "enum16":
bytes = BitConverter.GetBytes(ushort.Parse(defaultValue));
break;
case "int32":
case "blockindex32":
bytes = BitConverter.GetBytes(int.Parse(defaultValue));
break;
case "uint32":
case "enum32":
bytes = BitConverter.GetBytes(uint.Parse(defaultValue));
break;
case "float32":
bytes = BitConverter.GetBytes(float.Parse(defaultValue));
break;
case "flags8":
bytes = BitConverter.GetBytes((byte)getFlagValue(defaultValue));
break;
case "flags16":
bytes = BitConverter.GetBytes((ushort)getFlagValue(defaultValue));
break;
case "flags32":
bytes = BitConverter.GetBytes((uint)getFlagValue(defaultValue));
break;
default:
continue;
}
if (stream.ByteOrder == ByteOrder.BigEndian)
{
Array.Reverse(bytes);
}
defaultValues.Add(offset, bytes);
}
}
/// <summary>
/// The button 1_ click.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
/// <remarks></remarks>
private void button1_Click(object sender, EventArgs e)
{
ControlSwapper parent = (ControlSwapper)this.Parent.Parent.Parent;
// Add selected control
IFPIO.Option[] options = null;
//int strLength = 0;
Control con = null;
switch (((dataTypeStruct)comboBox1.SelectedItem).name.ToLower())
{
/*
* parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Byte, parent.lineNum));
* parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Short, parent.lineNum));
* parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Int, parent.lineNum));
* parent.splitContainer1.Panel2.Controls.Add(new DataValues(parent.name, null, parent.chunkoffset, IFPIO.ObjectEnum.Float, parent.lineNum));
*/
case "byte":
case "short":
case "ushort":
case "int":
case "uint":
case "float":
case "unknown":
case "unused":
con = new DataValues(
parent.name,
null,
parent.chunkoffset,
(IFPIO.ObjectEnum)
Enum.Parse(typeof(IFPIO.ObjectEnum), ((dataTypeStruct)comboBox1.SelectedItem).name, true),
parent.lineNum);
break;
case "char_enum":
case "enum":
case "long_enum":
options = new IFPIO.Option[((dataTypeStruct)comboBox1.SelectedItem).size << 3];
// Size * 8 bits
for (int x = 0; x < options.Length; x++)
{
options[x] = new IFPIO.Option("Bit " + x, x.ToString(), parent.lineNum);
}
if (parent.splitContainer1.Panel1.Controls[0] is Bitmask)
{
Bitmask b = (Bitmask)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in b.Options)
{
if (o.value < options.Length)
{
options[o.value].name = o.name;
}
}
}
;
if (parent.splitContainer1.Panel1.Controls[0] is Enums)
{
Enums en = (Enums)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in en.Options)
{
if (o.value < options.Length)
{
options[o.value].name = o.name;
}
}
}
;
con = new Enums(parent.name, null, parent.chunkoffset, options.Length, options, parent.lineNum);
break;
case "byte_flags":
case "word_flags":
case "long_flags":
options = new IFPIO.Option[((dataTypeStruct)comboBox1.SelectedItem).size << 3];
// Size * 8 bits
for (int x = 0; x < options.Length; x++)
{
options[x] = new IFPIO.Option("Bit " + x, x.ToString(), parent.lineNum);
}
if (parent.splitContainer1.Panel1.Controls[0] is Bitmask)
{
Bitmask b = (Bitmask)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in b.Options)
{
options[o.value].name = o.name;
}
}
;
if (parent.splitContainer1.Panel1.Controls[0] is Enums)
{
Enums en = (Enums)parent.splitContainer1.Panel1.Controls[0];
foreach (IFPIO.Option o in en.Options)
{
options[o.value].name = o.name;
}
}
;
con = new Bitmask(
parent.name, null, parent.chunkoffset, options.Length, options, parent.lineNum);
break;
case "stringid":
con = new SID(parent.name, null, parent.chunkoffset, parent.lineNum);
break;
case "string":
con = new EntStrings(
parent.name,
null,
parent.chunkoffset,
((dataTypeStruct)comboBox1.SelectedItem).size,
false,
parent.lineNum);
break;
case "unicodestring":
con = new EntStrings(
parent.name,
null,
parent.chunkoffset,
((dataTypeStruct)comboBox1.SelectedItem).size,
true,
parent.lineNum);
break;
case "block":
con = new TagBlock(parent.name, null, parent.chunkoffset, parent.lineNum);
break;
case "ident":
con = new Ident(parent.name, null, parent.chunkoffset, true, parent.lineNum);
break;
case "struct":
// Unhandled
//int ifkdn = 0;
break;
default:
{
return;
}
}
Button but = new Button();
but.Dock = DockStyle.Right;
but.Size = new Size(30, 30);
but.Text = "-";
but.Click += but_Click;
if (con != null)
{
con.Controls.Add(but);
// con.Enabled = false;
con.Dock = DockStyle.Top;
Point loc = con.Controls[con.Controls.Count - 2].Location;
loc.X -= 50;
con.Controls[con.Controls.Count - 2].Location = loc;
// con.TabIndex--;
parent.splitContainer1.Panel2.Controls.Add(con);
con.BringToFront();
((ControlSwapper)this.TopLevelControl).newControlSize +=
((ControlSwapper)this.TopLevelControl).getSizeOf(((dataTypeStruct)comboBox1.SelectedItem).name);
if (((ControlSwapper)this.TopLevelControl).label1.Text.Contains(" :: "))
{
((ControlSwapper)this.TopLevelControl).label1.Text =
((ControlSwapper)this.TopLevelControl).label1.Text.Remove(
((ControlSwapper)this.TopLevelControl).label1.Text.IndexOf(" :: "));
}
((ControlSwapper)this.TopLevelControl).label1.Text += " :: New Control Size : " +
((ControlSwapper)this.TopLevelControl).
newControlSize;
}
parent.splitContainer1.Panel2.Controls[parent.splitContainer1.Panel2.Controls.IndexOf(this)].
BringToFront();
parent.splitContainer1.Panel2.Controls[parent.splitContainer1.Panel2.Controls.IndexOf(this)].TabIndex++;
}
protected override void ProcessDefinition(XmlNode node, BlamLib.CheApe.ProjectState state, BlamLib.IO.XmlStream s)
{
StringIdFieldsInitialize(state);
string name_str;
switch (node.Name)
{
#region Tag Structs
case "structs":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "Struct") continue;
s.SaveCursor(n);
TagStruct block = new TagStruct(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Structs.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag struct definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Blocks
case "blocks":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagBlock") continue;
s.SaveCursor(n);
TagBlock block = new TagBlock(state, s);
s.RestoreCursor();
name_str = block.ToString();
try { Blocks.Add(name_str, block); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag block definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
#region Tag Groups
case "groups":
s.SaveCursor(node);
foreach (XmlNode n in s.Cursor.ChildNodes)
{
if (n.Name != "TagGroup") continue;
s.SaveCursor(n);
TagGroup group = new TagGroup(state, s);
s.RestoreCursor();
name_str = group.ToString();
try { Groups.Add(name_str, group); }
catch (ArgumentException) { Debug.LogFile.WriteLine(CheApe.Import.kDuplicateErrorStr, "tag group definition", name_str); }
}
s.RestoreCursor();
break;
#endregion
}
}
