private mValue ReadNode(XmlNode xmlNode) { //Indiciate what type of value this is. switch (xmlNode.Name.ToLower()) { case "reflexive": case "structure": case "reflex": case "struct": { //Initialize our instance of a reflexive. mReflexive reflexive = new mReflexive(); //Retrieve the structure's name. reflexive.Name = xmlNode.Attributes["name"].Value; //Retrieve its offset within its parent. reflexive.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Retrieve its chunk size. reflexive.Size = int.Parse(xmlNode.Attributes["size"].Value); //Retrieve its visibility flag. reflexive.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the value list for the reflexive reflexive.Values = new List <mValue>(); //Recursively add any nodes that belong to it. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //Get our returned value. mValue returnedVal = ReadNode(xmlNode.ChildNodes[i]); //If its not some unknown node that couldnt be read... if (returnedVal.Attributes != mValue.ObjectAttributes.None) { //Then add it to this reflexive value list. reflexive.Values.Add(returnedVal); } } //Return our reflexive return(reflexive); } case "tagref": case "tag": { //Initialize our instance of TagRef mTagRef tagRef = new mTagRef(); //Assign the name tagRef.Name = xmlNode.Attributes["name"].Value; //Assign the offset tagRef.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag tagRef.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(tagRef); } case "ident": case "id": case "tagid": { //Initialize our instance of ident mIdent ident = new mIdent(); //Assign the name ident.Name = xmlNode.Attributes["name"].Value; //Assign the offset ident.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag ident.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(ident); } case "sid": case "stringid": case "stringidentifier": { //Initialize our instance of string mStringID stringID = new mStringID(); //Assign the name stringID.Name = xmlNode.Attributes["name"].Value; //Assign the offset stringID.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag stringID.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(stringID); } case "bitmask8": case "bit8": { //Initialize our instance of bitmask8 mBitmask8 bitmask8 = new mBitmask8(); //Assign the name bitmask8.Name = xmlNode.Attributes["name"].Value; //Assign the offset bitmask8.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag bitmask8.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the bitOption list. bitmask8.Options = new List <mBitOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mBitOption bitOption = new mBitOption(); //Get the name of the bit bitOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value bitOption.BitIndex = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList bitmask8.Options.Add(bitOption); } } //return the value return(bitmask8); } case "bitmask16": case "bit16": { //Initialize our instance of bitmask16 mBitmask16 bitmask16 = new mBitmask16(); //Assign the name bitmask16.Name = xmlNode.Attributes["name"].Value; //Assign the offset bitmask16.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag bitmask16.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the bitOption list. bitmask16.Options = new List <mBitOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mBitOption bitOption = new mBitOption(); //Get the name of the bit bitOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value bitOption.BitIndex = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList bitmask16.Options.Add(bitOption); } } //return the value return(bitmask16); } case "bitmask32": case "bit32": { //Initialize our instance of bitmask32 mBitmask32 bitmask32 = new mBitmask32(); //Assign the name bitmask32.Name = xmlNode.Attributes["name"].Value; //Assign the offset bitmask32.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag bitmask32.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the bitOption list. bitmask32.Options = new List <mBitOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mBitOption bitOption = new mBitOption(); //Get the name of the bit bitOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value bitOption.BitIndex = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList bitmask32.Options.Add(bitOption); } } //return the value return(bitmask32); } case "enum8": { //Initialize our instance of enum8 mEnum8 enum8 = new mEnum8(); //Assign the name enum8.Name = xmlNode.Attributes["name"].Value; //Assign the offset enum8.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag enum8.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the enumOption list. enum8.Options = new List <mEnumOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mEnumOption enumOption = new mEnumOption(); //Get the name of the bit enumOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value enumOption.Value = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList enum8.Options.Add(enumOption); } } //return the value return(enum8); } case "enum16": { //Initialize our instance of enum16 mEnum16 enum16 = new mEnum16(); //Assign the name enum16.Name = xmlNode.Attributes["name"].Value; //Assign the offset enum16.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag enum16.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the enumOption list. enum16.Options = new List <mEnumOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mEnumOption enumOption = new mEnumOption(); //Get the name of the bit enumOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value enumOption.Value = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList enum16.Options.Add(enumOption); } } //return the value return(enum16); } case "enum32": { //Initialize our instance of enum32 mEnum32 enum32 = new mEnum32(); //Assign the name enum32.Name = xmlNode.Attributes["name"].Value; //Assign the offset enum32.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag enum32.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //Initialize the enumOption list. enum32.Options = new List <mEnumOption>(); //Loop through the children nodes for options. for (int i = 0; i < xmlNode.ChildNodes.Count; i++) { //if its an option... if (xmlNode.ChildNodes[i].Name.ToLower() == "option") { //then initialize a new instance of option mEnumOption enumOption = new mEnumOption(); //Get the name of the bit enumOption.Name = xmlNode.ChildNodes[i].Attributes["name"].Value; //Get the bit value enumOption.Value = int.Parse(xmlNode.ChildNodes[i].Attributes["value"].Value); //Add it to the bitList enum32.Options.Add(enumOption); } } //return the value return(enum32); } case "int8": case "byte": { //Initialize our instance of byte mByte byteVal = new mByte(); //Assign the name byteVal.Name = xmlNode.Attributes["name"].Value; //Assign the offset byteVal.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag byteVal.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(byteVal); } case "int16": case "short": { //Initialize our instance of int16 mInt16 int16Val = new mInt16(); //Assign the name int16Val.Name = xmlNode.Attributes["name"].Value; //Assign the offset int16Val.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag int16Val.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(int16Val); } case "uint16": case "ushort": { //Initialize our instance of uint16 mUInt16 uint16Val = new mUInt16(); //Assign the name uint16Val.Name = xmlNode.Attributes["name"].Value; //Assign the offset uint16Val.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag uint16Val.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(uint16Val); } case "int32": case "long": case "int": { //Initialize our instance of int32 mInt32 int32Val = new mInt32(); //Assign the name int32Val.Name = xmlNode.Attributes["name"].Value; //Assign the offset int32Val.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag int32Val.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(int32Val); } case "uint32": case "ulong": case "uint": { //Initialize our instance of uint32 mUInt32 uint32Val = new mUInt32(); //Assign the name uint32Val.Name = xmlNode.Attributes["name"].Value; //Assign the offset uint32Val.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag uint32Val.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(uint32Val); } case "single": case "float": { //Initialize our instance of float mFloat floatVal = new mFloat(); //Assign the name floatVal.Name = xmlNode.Attributes["name"].Value; //Assign the offset floatVal.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag floatVal.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(floatVal); } case "string32": case "32string": { //Initialize our instance of string32 mString32 string32 = new mString32(); //Assign the name string32.Name = xmlNode.Attributes["name"].Value; //Assign the offset string32.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag string32.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(string32); } case "string256": case "256string": { //Initialize our instance of string32 mString256 string256 = new mString256(); //Assign the name string256.Name = xmlNode.Attributes["name"].Value; //Assign the offset string256.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag string256.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(string256); } case "unic64": case "unicode64": case "64unic": case "64unicode": { //Initialize our instance of unicode64 mUnicode64 unicode64 = new mUnicode64(); //Assign the name unicode64.Name = xmlNode.Attributes["name"].Value; //Assign the offset unicode64.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag unicode64.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(unicode64); } case "unic256": case "unicode256": case "256unic": case "256unicode": { //Initialize our instance of unicode64 mUnicode256 unicode256 = new mUnicode256(); //Assign the name unicode256.Name = xmlNode.Attributes["name"].Value; //Assign the offset unicode256.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag unicode256.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(unicode256); } case "undefined": case "unknown": { //Initialize our instance of undefined mUndefined undefined = new mUndefined(); //Assign the name undefined.Name = xmlNode.Attributes["name"].Value; //Assign the offset undefined.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag undefined.Visible = bool.Parse(xmlNode.Attributes["visible"].Value); //return the value return(undefined); } case "unused": case "blank": { //Initialize our instance of undefined mUnused unused = new mUnused(); //Assign the offset unused.Offset = int.Parse(xmlNode.Attributes["offset"].Value); //Assign the visibility flag unused.Size = int.Parse(xmlNode.Attributes["size"].Value); //return the value return(unused); } } //If all else fails, make a 'none' value. mValue blankVal = new mValue(); blankVal.Attributes = mValue.ObjectAttributes.None; return(blankVal); }
private void LoadControls() { pnlContainer.Controls.Clear(); int yLoc = 5; foreach (XmlNode n in element.ChildNodes) { iValue val; try { val = new iValue(n); } catch { continue; } if (!val.Visible && !showInvis) { continue; } MetaViewerControl mvc = new MetaViewerControl(); switch (val.Type) { case iValue.ValueType.Comment: mvc = new mComment(val, cache); break; case iValue.ValueType.Struct: mvc = new mStructure(val, cache, tag, showInvis); ((mStructure)mvc).RequestTagLoad += new RequestTagLoadEventHandler(MetaViewer_TagLoadRequested); ((mStructure)mvc).ResizeNeeded += new ResizeNeededEvent(mStructure_ResizeNeeded); break; case iValue.ValueType.TagRef: mvc = new mTagRef(val, cache); ((mTagRef)mvc).RequestTagLoad += new RequestTagLoadEventHandler(MetaViewer_TagLoadRequested); break; case iValue.ValueType.String: case iValue.ValueType.StringID: mvc = new mString(val, cache); break; case iValue.ValueType.Bitmask8: case iValue.ValueType.Bitmask16: case iValue.ValueType.Bitmask32: mvc = new mBitmask(val, cache); break; case iValue.ValueType.Int8: case iValue.ValueType.Int16: case iValue.ValueType.Int32: case iValue.ValueType.Float32: case iValue.ValueType.UInt16: case iValue.ValueType.UInt32: case iValue.ValueType.Undefined: case iValue.ValueType.RawID: mvc = new mValue(val, cache); break; case iValue.ValueType.Enum8: case iValue.ValueType.Enum16: case iValue.ValueType.Enum32: mvc = new mEnum(val, cache); break; case iValue.ValueType.ShortBounds: case iValue.ValueType.RealBounds: case iValue.ValueType.ShortPoint2D: case iValue.ValueType.RealPoint2D: case iValue.ValueType.RealPoint3D: case iValue.ValueType.RealPoint4D: case iValue.ValueType.RealVector2D: case iValue.ValueType.RealVector3D: case iValue.ValueType.RealVector4D: case iValue.ValueType.Colour32RGB: case iValue.ValueType.Colour32ARGB: mvc = new mMultiValue(val, cache); break; } mvc.Reload(tag.Offset); if (mvc is mStructure || mvc is mComment) { yLoc += 5; } mvc.Location = new Point(5, yLoc); yLoc += mvc.Height; if (mvc is mStructure || mvc is mComment) { yLoc += 5; } pnlContainer.Controls.Add(mvc); } }
public void MapPluginWithPDBList(List <mValue> mValueList, List <PluginDataBlock> PDBList, int chunkSize, int unknownStructCount) { //Loop until we hit our chunkSize for (int i = 0; i < chunkSize; i += 4) { //Create our reflexive list List <PluginDataBlock> PDBList2 = new List <PluginDataBlock>(); //Loop through each PDBList foreach (PluginDataBlock PDB in PDBList) { //Loop for each reflexive foreach (Reflexive_DataBlock RDB in PDB.Reflexive_Data_Blocks) { if (RDB.Offset_In_Parent == i) { //Add it to our PDB list PDBList2.Add(RDB); } } } //If we got reflexives if (PDBList2.Count != 0) { //Initialize our reflexive mReflexive mReflex = new mReflexive(); mReflex.Name = "Unknown " + unknownStructCount; unknownStructCount++; mReflex.Offset = i; mReflex.Size = FindMostLikelySizeForChunk(PDBList2); mReflex.Visible = false; //Add it to our list mValueList.Add(mReflex); //Map more. MapPluginWithPDBList(mReflex.Values, PDBList2, mReflex.Size, unknownStructCount); //Add 8 to our i. i += 8; } else { //Our bool that indicates if we found an ident. bool foundIdent = false; //Loop through each PDBList foreach (PluginDataBlock PDB in PDBList) { //Loop for each ident foreach (Tag_Ident ident in PDB.Tag_Idents) { if (ident.Offset_In_Parent == i) { //Initialize our ident parts mTagRef tRef = new mTagRef(); tRef.Name = "Unknown"; tRef.Offset = i; tRef.Visible = false; mIdent tIdent = new mIdent(); tIdent.Name = "Unknown"; tIdent.Offset = i + 12; tIdent.Visible = false; //Add it to our list mValueList.Add(tRef); mValueList.Add(tIdent); //Add 12 more to i i += 12; //We found our ident. foundIdent = true; //Leave. break; } } //If we found our ident if (foundIdent) { //Leave break; } } if (!foundIdent) { //If we got 4 bytes left. if (chunkSize - i >= 4) { //Let's make our unidentified mUndefined mU = new mUndefined(); mU.Name = "Unknown"; mU.Offset = i; mU.Visible = false; //Add it to our list mValueList.Add(mU); } else { //If we got 2 bytes left if (chunkSize - i >= 2) { //Make our short mInt16 m16 = new mInt16(); m16.Name = "Unknown"; m16.Offset = i; m16.Visible = false; //Add it to our list mValueList.Add(m16); //Take 2 away from i, since it'll add 4, it makes it progress 2 i -= 2; } else { if (chunkSize - i == 1) { //Make our byte mByte mB = new mByte(); mB.Name = "Unknown"; mB.Offset = i; mB.Visible = false; //Add it to our list mValueList.Add(mB); //We're done, we dont need to take away 3 to make i increment 1. } } } } } } }