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); }
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)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(); }
public TagHeaderTreeNode(string name, XmlNode node, TagBlock tagblock) : base(name) { Values = node; TagBlock = tagblock; }
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 } }