private void AddElement(ElementStructure es, ref int offset, byte[] data, ref int groupOffset,
ref int CurrentGroup)
{
var panel1 = new Panel();
panel1.AutoSize = true;
panel1.Width = fpanel1.Width - 10;
panel1.Height = 1;
panel1.Anchor = AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Left | AnchorStyles.Bottom;
int ypos = 0;
uint flagValue = 0; // value if flags is set
byte flagSize = 4;
bool hasFlags = (es.options.Length == 0 && es.flags.Length > 1);
var tb = new TextBox();
boxes.Add(tb);
if (es.group != 0)
{
var cb = new CheckBox();
cb.Text = "Use this value?";
panel1.Controls.Add(cb);
cb.Location = new Point(10, ypos);
ypos += 24;
cb.Tag = new cbTag(es.group, tb);
if (CurrentGroup != es.group)
{
cb.Checked = true;
}
else
{
tb.Enabled = false;
}
cb.CheckedChanged += CheckBox_CheckedChanged;
}
if (es.optional || es.repeat > 0 && repeatcount > 0)
{
var cb = new CheckBox();
cb.Text = "Use this value?";
panel1.Controls.Add(cb);
cb.Location = new Point(10, ypos);
ypos += 24;
cb.Tag = new repeatCbTag(tb, elements.Count);
if (data == null)
{
tb.Enabled = false;
}
else
{
cb.Checked = true;
}
cb.CheckedChanged += RepeatCheckBox_CheckedChanged;
}
if ((CurrentGroup == 0 && es.group != 0) || (CurrentGroup != 0 && es.group != 0 && CurrentGroup != es.group))
{
CurrentGroup = es.group;
groupOffset = offset;
}
else if (CurrentGroup != 0 && es.group == 0)
{
CurrentGroup = 0;
}
else if (CurrentGroup != 0 && CurrentGroup == es.group)
{
offset = groupOffset;
}
valueTypes.Add(es.type);
if (data != null)
{
switch (es.type)
{
case ElementValueType.UInt:
{
var v = TypeConverter.h2i(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]);
flagValue = v;
flagSize = 4;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X8") : v.ToString();
offset += 4;
}
break;
case ElementValueType.Int:
{
var v = TypeConverter.h2si(data[offset], data[offset + 1], data[offset + 2],
data[offset + 3]);
flagValue = (uint)v;
flagSize = 4;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X8") : v.ToString();
offset += 4;
}
break;
case ElementValueType.FormID:
tb.Text =
TypeConverter.h2i(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]).
ToString("X8");
offset += 4;
break;
case ElementValueType.Float:
tb.Text =
TypeConverter.h2f(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]).
ToString();
offset += 4;
break;
case ElementValueType.UShort:
{
var v = TypeConverter.h2s(data[offset], data[offset + 1]);
flagValue = v;
flagSize = 2;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X4") : v.ToString();
offset += 2;
}
break;
case ElementValueType.Short:
{
var v = TypeConverter.h2ss(data[offset], data[offset + 1]);
flagValue = (uint)v;
flagSize = 2;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X4") : v.ToString();
offset += 2;
}
break;
case ElementValueType.Byte:
{
var v = data[offset];
flagValue = v;
flagSize = 1;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X2") : v.ToString();
offset++;
}
break;
case ElementValueType.SByte:
{
var v = (sbyte)data[offset];
flagValue = (uint)v;
flagSize = 1;
tb.Text = hasFlags || es.hexview ? "0x" + v.ToString("X2") : v.ToString();
offset++;
}
break;
case ElementValueType.String:
{
string s = "";
while (data[offset] != 0)
{
s += (char)data[offset++];
}
offset++;
tb.Text = s;
tb.Width += 200;
}
break;
case ElementValueType.BString:
{
int len = TypeConverter.h2s(data[offset], data[offset + 1]);
string s = Encoding.CP1252.GetString(data, offset + 2, len);
offset = offset + (2 + len);
tb.Text = s;
tb.Width += 200;
}
break;
case ElementValueType.IString:
{
int len = TypeConverter.h2si(data[offset], data[offset + 1], data[offset + 2], data[offset + 3]);
string s = Encoding.CP1252.GetString(data, offset + 4, len);
offset = offset + (4 + len);
tb.Text = s;
tb.Width += 200;
}
break;
case ElementValueType.LString:
{
int left = data.Length - offset;
uint id = (left < 4)
? 0
: TypeConverter.h2i(data[offset], data[offset + 1], data[offset + 2],
data[offset + 3]);
bool isString = TypeConverter.IsLikelyString(new ArraySegment <byte>(data, offset, left));
int strOffset = offset;
string s = null;
if (isString)
{
s = TypeConverter.GetString(new ArraySegment <byte>(data, offset, data.Length - offset));
tb.Text = 0.ToString("X8");
offset += s.Length;
}
else
{
offset += 4;
tb.Text = id.ToString("X8");
if (strIDLookup != null)
{
s = strIDLookup(id);
}
}
tb.Tag = new lTag(tb, s, data, strOffset, isString);
}
break;
case ElementValueType.Str4:
{
string s = Encoding.CP1252.GetString(data, offset, 4);
offset += 4;
tb.MaxLength = 4;
tb.Text = s;
}
break;
default:
throw new ApplicationException();
}
}
else
{
if (es.type == ElementValueType.String || es.type == ElementValueType.BString ||
es.type == ElementValueType.LString || es.type == ElementValueType.IString)
{
tb.Width += 200;
}
if (removedStrings.ContainsKey(boxes.Count - 1))
{
tb.Text = removedStrings[boxes.Count - 1];
}
}
var l = new Label();
l.AutoSize = true;
string tmp = es.type.ToString();
l.Text = tmp + ": " + es.name + (!string.IsNullOrEmpty(es.desc) ? (" (" + es.desc + ")") : "");
panel1.Controls.Add(tb);
tb.Location = new Point(10, ypos);
if (es.multiline)
{
tb.Multiline = true;
ypos += tb.Height * 5;
tb.Height *= 6;
}
panel1.Controls.Add(l);
l.Location = new Point(tb.Right + 10, ypos + 3);
string[] options = null;
if (es.type == ElementValueType.FormID)
{
ypos += 28;
var b = new Button();
b.Text = "FormID lookup";
b.Click += LookupFormID_Click;
panel1.Controls.Add(b);
b.Location = new Point(20, ypos);
var tb2 = new TextBox();
tb2.Width += 200;
tb2.ReadOnly = true;
panel1.Controls.Add(tb2);
tb2.Location = new Point(b.Right + 10, ypos);
b.Tag = new bTag(tb, tb2);
if (es.FormIDType != null)
{
if (cachedFormIDs.ContainsKey(es.FormIDType))
{
options = cachedFormIDs[es.FormIDType];
}
else
{
options = formIDScan(es.FormIDType);
cachedFormIDs[es.FormIDType] = options;
}
}
}
else if (es.type == ElementValueType.LString)
{
ypos += 24;
var ltag = tb.Tag as lTag;
ltag.cb = new CheckBox();
ltag.cb.Width = ltag.cb.Height;
ltag.cb.Checked = ltag.isString;
panel1.Controls.Add(ltag.cb);
ltag.cb.Location = new Point(8, ypos);
ltag.str = new TextBox();
//ltag.str.Font = this.baseFont;
ltag.str.Width += (200 - ltag.cb.Width + 8);
panel1.Controls.Add(ltag.str);
ltag.str.Location = new Point(ltag.cb.Location.X + ltag.cb.Width + 8, ypos);
ltag.str.Text = string.IsNullOrEmpty(ltag.disp) ? "" : ltag.disp;
ypos += 24;
}
else if (es.options != null)
{
options = es.options;
}
if (options != null && options.Length > 0)
{
ypos += 28;
var cmb = new ComboBox();
cmb.Tag = tb;
cmb.Width += 200;
for (int j = 0; j < options.Length; j += 2)
{
cmb.Items.Add(new comboBoxItem(options[j], options[j + 1]));
}
cmb.KeyPress += cb_KeyPress;
cmb.ContextMenu = new ContextMenu();
cmb.SelectedIndexChanged += cb_SelectedIndexChanged;
panel1.Controls.Add(cmb);
cmb.Location = new Point(20, ypos);
}
if (hasFlags) // add flags combo box to the side
{
var ccb = new FlagComboBox();
ccb.Tag = tb;
ccb.SetItems(es.flags, flagSize);
ccb.SetState(flagValue);
ccb.TextChanged += delegate
{
uint value = ccb.GetState();
var text = ccb.Tag as TextBox;
text.Text = "0x" + value.ToString("X");
};
ccb.Location = new Point(l.Location.X + l.Width + 10, tb.Top);
ccb.Width = Math.Max(ccb.Width, Width - 50 - (ccb.Location.X));
ccb.Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right;
panel1.Controls.Add(ccb);
}
fpanel1.Controls.Add(panel1);
elements.Add(panel1);
}
/// <summary>
/// Extract any internalized strings and put in string table
/// </summary>
/// <param name="plugin"></param>
public static int ExtractInternalStrings(Plugin plugin)
{
int count = 0;
uint maxid = plugin.Masters.Max(x => x.Strings.Count > 0 ? x.Strings.Keys.Max() : 0);
bool anyModified = false;
foreach (var record in plugin.Enumerate().OfType <Record>())
{
record.MatchRecordStructureToRecord();
foreach (var sr in record.SubRecords)
{
var elements = record.EnumerateElements(sr, rawData: true).ToList();
foreach (var elem in elements)
{
if (elem.Structure != null && elem.Structure.type == ElementValueType.LString)
{
var data = elem.Data;
uint id = TypeConverter.h2i(data);
if (id == 0)
{
continue;
}
if (data.Count == 4 && TypeConverter.IsLikelyString(data))
{
string str;
if (plugin.Strings.TryGetValue(id, out str))
{
continue;
}
}
if (data.Count != 4 || TypeConverter.IsLikelyString(data))
{
string value = TypeConverter.GetString(data);
if (!String.IsNullOrEmpty(value))
{
uint nextid = Math.Max(maxid, plugin.Strings.Count == 0 ? 0 : plugin.Strings.Keys.Max()) + 1;
int idx = plugin.Strings.FindValue(value);
if (idx >= 0)
{
nextid = plugin.Strings.ElementAt(idx).Key;
}
else
{
plugin.Strings[nextid] = value;
}
elem.AssignValue <ArraySegment <byte> >(
new ArraySegment <byte>((byte[])TypeConverter.i2h(nextid).Clone()));
++count;
}
}
}
}
if (elements.Any(x => x.Changed))
{
// need to repack the structure
using (var ms = new MemoryStream(sr.GetReadonlyData().Length))
{
foreach (var seg in elements.Select(elem => elem.Data))
{
ms.Write(seg.Array, seg.Offset, seg.Count);
}
sr.SetData(ms.ToArray());
}
anyModified = true;
}
}
}
if (anyModified)
{
var tes4 = plugin.Records.OfType <Record>().FirstOrDefault(x => x.Name == "TES4");
if (tes4 != null)
{
tes4.Flags1 |= 0x00000080U;
}
}
return(count);
}
public static Element CreateElement(ElementStructure es, byte[] data, ref int offset, bool rawData)
{
int maxlen = data.Length - offset;
Element elem = null;
try
{
int len;
switch (es.type)
{
case ElementValueType.Int:
len = maxlen >= sizeof(int) ? sizeof(int) : maxlen;
elem = new Element(es, ElementValueType.Int, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.UInt:
case ElementValueType.FormID:
len = maxlen >= sizeof(uint) ? sizeof(uint) : maxlen;
elem = new Element(es, ElementValueType.UInt, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.Float:
len = maxlen >= sizeof(float) ? sizeof(float) : maxlen;
elem = new Element(es, ElementValueType.Float, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.Short:
len = maxlen >= sizeof(short) ? sizeof(short) : maxlen;
elem = new Element(es, ElementValueType.Short, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.UShort:
len = maxlen >= sizeof(ushort) ? sizeof(ushort) : maxlen;
elem = new Element(es, ElementValueType.UShort, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.SByte:
len = maxlen >= sizeof(sbyte) ? sizeof(sbyte) : maxlen;
elem = new Element(es, ElementValueType.SByte, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.Byte:
len = maxlen >= sizeof(byte) ? sizeof(byte) : maxlen;
elem = new Element(es, ElementValueType.Byte, new ArraySegment <byte>(data, offset, len));
offset += len;
break;
case ElementValueType.String:
len = 0;
for (int i = offset; i < data.Length && data[i] != 0; ++i, ++len)
{
;
}
if (rawData) // raw form includes the zero termination byte
{
len = (len == 0 ? 0 : len + 1);
elem = new Element(es, ElementValueType.String, new ArraySegment <byte>(data, offset, len));
offset += len;
}
else
{
elem = new Element(es, ElementValueType.String, new ArraySegment <byte>(data, offset, len));
offset += (len == 0 ? 0 : len + 1);
}
break;
case ElementValueType.BString:
if (maxlen >= sizeof(ushort))
{
len = TypeConverter.h2s(data[offset], data[offset + 1]);
len = (len < maxlen - 2) ? len : maxlen - 2;
if (rawData) // raw data includes short prefix
{
elem = new Element(es, ElementValueType.BString,
new ArraySegment <byte>(data, offset, len + 2));
offset += (len + 2);
}
else
{
elem = new Element(es, ElementValueType.String,
new ArraySegment <byte>(data, offset + 2, len));
offset += (len + 2);
}
}
else
{
if (rawData)
{
elem = new Element(es, ElementValueType.BString,
new ArraySegment <byte>(new byte[2] {
0, 0
}));
}
else
{
elem = new Element(es, ElementValueType.String, new ArraySegment <byte>(new byte[0]));
}
offset += maxlen;
}
break;
case ElementValueType.Str4:
len = maxlen >= 4 ? 4 : maxlen;
if (rawData)
{
elem = new Element(es, ElementValueType.Str4, new ArraySegment <byte>(data, offset, len));
}
else
{
elem = new Element(es, ElementValueType.String, new ArraySegment <byte>(data, offset, len));
}
offset += len;
break;
case ElementValueType.LString:
if (maxlen < sizeof(int))
{
elem = new Element(es, ElementValueType.String, new ArraySegment <byte>(data, offset, maxlen));
offset += maxlen;
}
else
{
len = maxlen;
var blob = new ArraySegment <byte>(data, offset, len);
bool isString = TypeConverter.IsLikelyString(blob);
if (!isString)
{
elem = new Element(es, ElementValueType.UInt, new ArraySegment <byte>(data, offset, len));
offset += 4;
}
else
{
len = 0;
for (int i = offset; i < data.Length && data[i] != 0; ++i, ++len)
{
;
}
if (rawData) // lstring as raw string includes the terminating null
{
len = (len == 0 ? 0 : len + 1);
elem = new Element(es, ElementValueType.LString,
new ArraySegment <byte>(data, offset, len));
offset += len;
}
else
{
elem = new Element(es, ElementValueType.String,
new ArraySegment <byte>(data, offset, len));
offset += (len == 0 ? 0 : len + 1);
}
}
}
break;
default:
elem = new Element(es, ElementValueType.Blob, new ArraySegment <byte>(data, offset, maxlen));
offset += maxlen;
break;
}
}
catch
{
}
finally
{
if (offset > data.Length)
{
offset = data.Length;
}
}
return(elem);
}