private static CVariable GetRedProperty(IEditableVariable cvar, string propertyName)
{
foreach (var member in REDReflection.GetMembers(cvar))
{
try
{
var redname = REDReflection.GetREDNameString(member);
if (redname != propertyName)
{
continue;
}
var prop = cvar.accessor[cvar, member.Name];
var cprop = prop as CVariable;
return(cprop);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
return(null);
}
public override void Read(BinaryReader file, uint size)
{
CVariable parsedvar = null;
var varsize = file.ReadUInt32();
var buffer = file.ReadBytes((int)varsize - 4);
using (var ms = new MemoryStream(buffer))
using (var br = new BinaryReader(ms))
{
var nameId = br.ReadUInt16();
var typeId = br.ReadUInt16();
if (nameId == 0)
{
return;
}
var typename = cr2w.Names[typeId].Str;
var varname = cr2w.Names[nameId].Str;
parsedvar = CR2WTypeManager.Create(typename, varname, cr2w, this);
parsedvar.IsSerialized = true;
parsedvar.Read(br, size);
this.SetREDName(varname);
}
Variant = parsedvar;
}
public static void SetFromDictionary(this IEditableVariable cvar, Dictionary <string, object> dictionary)
{
if (cvar is IREDVariant var)
{
var type = dictionary["Type"] as string;
var name = "Variant";
if (dictionary.ContainsKey("Name"))
{
name = dictionary["Name"] as string;
}
var jvalue = dictionary["Variant"];
var variant = CR2WTypeManager.Create(type, name, cvar.Cr2wFile as IRed4EngineFile, cvar as CVariable);
variant.IsSerialized = true;
variant.SetFromJObject(jvalue);
var.SetVariant(variant);
return;
}
foreach (var(propertyName, value) in dictionary)
{
var redProperty = GetRedProperty(cvar, propertyName);
if (redProperty == null)
{
throw new InvalidParsingException("not a CVariable");
}
redProperty.SetFromJObject(value);
}
}
private void treeView_FormatRow(object sender, FormatRowEventArgs e)
{
IEditableVariable model = (IEditableVariable)e.Model;
if (model != null && (model.IsSerialized))
{
//if (!showOnlySerialized)
{
int themeID = (int)UIController.Get().Configuration.ColorTheme;
var forecolor = Color.FromArgb(UIController.Get().Configuration.CustomHighlightColor[themeID]);
e.Item.ForeColor = forecolor;
}
}
else
{
}
// check for errors
// do this here until we have a proper error log
if ((model is IPtrAccessor ptr && ptr.Reference == null) ||
(model is IHandleAccessor handle && handle.ChunkHandle && handle.Reference == null))
{
if (model.IsSerialized)
{
e.Item.ForeColor = Color.Red;
}
}
}
public override void RemoveVariable(IEditableVariable child)
{
if (child is CName v)
{
flags.Remove(v);
v.ParentVariable = null;
}
}
public override void RemoveVariable(IEditableVariable child)
{
if (child is T)
{
elements.Remove(child as T);
UpdateNames();
}
}
public override void AddVariable(IEditableVariable var)
{
if (var is CName)
{
var tag = (CName)var;
tags.Add(tag);
}
}
internal VariableListNode CreatePropertyLayout(IEditableVariable v)
{
var root = AddListViewItems(v);
Root.Add(root);
return(root);
}
public ChunkPropertyViewModel(IEditableVariable prop)
{
_property = prop;
Name = prop.REDName;
Type = prop.REDType;
Value = prop.REDValue;
}
public override void RemoveVariable(IEditableVariable child)
{
if (child is CName)
{
var tag = (CName)child;
tags.Remove(tag);
tag.ParentVariable = null;
}
}
public override void RemoveVariable(IEditableVariable child)
{
if (child is CVariable)
{
var v = (CVariable)child;
array.Remove(v);
v.ParentVariable = null;
}
}
public override void AddVariable(IEditableVariable variable)
{
if (variable is T tvar)
{
variable.SetREDName(Elements.Count.ToString());
tvar.IsSerialized = true;
Elements.Add(tvar);
}
}
public override bool CanRemoveVariable(IEditableVariable child)
{
//FIXME
if (child is CVariable v)
{
//return flags.Contains(v);
}
return(true);
}
public override bool RemoveVariable(IEditableVariable child)
{
if (child is T tvar)
{
Elements.Remove(tvar);
UpdateNames();
return(true);
}
return(false);
}
public override bool RemoveVariable(IEditableVariable child)
{
if (child is CName)
{
var tag = (CName)child;
tags.Remove(tag);
return(true);
}
return(false);
}
public override bool CanRemoveVariable(IEditableVariable child)
{
if (child is CName)
{
var tag = (CName)child;
return(tags.Contains(tag));
}
return(false);
}
public override bool CanRemoveVariable(IEditableVariable child)
{
if (child is CVariable)
{
var v = (CVariable)child;
return(array.Contains(v));
}
return(false);
}
public void RemoveVariable(IEditableVariable child)
{
if (child is T)
{
List.Remove((T)child);
if (child is CVariable)
{
((CVariable)child).ParentVariable = null;
}
}
}
public ChunkPropertyViewModel(IEditableVariable prop)
{
Property = prop;
var disposable = Property.ChildrEditableVariables
.AsObservableChangeSet()
.Transform(GetViewModel)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _children)
.Subscribe();
}
public override void AddVariable(IEditableVariable var)
{
switch (var)
{
case CBytes b:
{
Bytes = new byte[b.Bytes.Length];
Buffer.BlockCopy(b.Bytes, 0, Bytes, 0, b.Bytes.Length);
break;
}
}
}
public override void RemoveVariable(IEditableVariable child)
{
if (child is CVariable)
{
var v = (CVariable)child;
array.Remove(v);
v.ParentVariable = null;
if (fixedTypeArray)
{
Type = "[" + array.Count + "]" + elementtype;
}
}
}
public static IEditableVariable CopyViaBuffer(IEditableVariable source, IEditableVariable destination)
{
using (MemoryStream ms = new MemoryStream())
using (BinaryWriter bw = new BinaryWriter(ms))
{
source.Write(bw);
ms.Position = 0;
using (BinaryReader reader = new BinaryReader(ms))
{
destination.Read(reader, (uint)ms.Length);
}
}
return(destination);
}
public static void SetFromDictionary(this IEditableVariable cvar, Dictionary <string, object> dictionary)
{
if (cvar is IREDVariant var)
{
var type = dictionary["Type"] as string;
var name = "Variant";
if (dictionary.ContainsKey("Name"))
{
name = dictionary["Name"] as string;
}
var jvalue = dictionary["Variant"];
var variant = CR2WTypeManager.Create(type, name, cvar.Cr2wFile as IRed4EngineFile, cvar as CVariable);
variant.IsSerialized = true;
variant.SetFromJObject(jvalue);
var.SetVariant(variant);
return;
}
if (cvar is ICurveDataAccessor curve)
{
var interpolation = dictionary["InterpolationType"];
var interpolationByte = int.Parse(interpolation.ToString());
curve.SetInterpolationType((EInterpolationType)interpolationByte);
var link = dictionary["LinkType"];
var linkByte = int.Parse(link.ToString());
curve.SetLinkType((ESegmentsLinkType)linkByte);
curve.SetFromJObject(dictionary["Elements"]);
return;
}
foreach (var(propertyName, value) in dictionary)
{
var redProperty = GetRedProperty(cvar, propertyName);
if (redProperty == null)
{
throw new InvalidParsingException("not a CVariable");
}
redProperty.SetFromJObject(value);
}
}
public override CVariable SetValue(object val)
{
//if (val is CVariable)
//{
// Variant = (CVariable)val;
//}
/*else*/ if (val is CVariant cvar)
{
var context = new CR2WCopyAction()
{
DestinationFile = this.cr2w,
Parent = this.ParentVar as CVariable
};
this.Variant = cvar.Variant.Copy(context);
}
return(this);
}
public override void Read(BinaryReader file, uint size)
{
var typeId = file.ReadUInt16();
var typename = cr2w.Names[typeId].Str;
var varsize = file.ReadUInt32() - 4;
if (varsize > 0)
{
Variant = CR2WTypeManager.Create(typename, nameof(Variant), cr2w, this);
Variant.Read(file, varsize);
Variant.IsSerialized = true;
}
else
{
// do nothing I guess?
}
}
private void RemoveListElement(HotKeyEventArgs e)
{
// removing variables from arrays
if (treeView.SelectedObjects.Count <= 0)
{
return;
}
var temp = new IEditableVariable[treeView.SelectedObjects.Count];
treeView.SelectedObjects.CopyTo(temp, 0);
// remove target chunks if any ptr
var toberemovedchunks = new List <CR2WExportWrapper>();
foreach (var selectedobject in treeView.SelectedObjects)
{
if (selectedobject is IChunkPtrAccessor chunkptraccessor &&
chunkptraccessor.ParentVar != null &&
chunkptraccessor.ParentVar.CanRemoveVariable(chunkptraccessor) &&
chunkptraccessor.Reference != null)
{
toberemovedchunks.Add(chunkptraccessor.Reference);
}
}
if (toberemovedchunks.Any())
{
if (viewModel.File is CR2WFile file)
{
file.RemoveChunks(
toberemovedchunks,
false,
(CR2WFile.EChunkDisplayMode)viewModel.chunkDisplayMode);
}
}
foreach (var node in temp)
{
node.ParentVar.RemoveVariable(node);
}
UpdateTreeListView();
}
private VariableListNode AddListViewItems(IEditableVariable v, VariableListNode parent = null,
int arrayindex = 0)
{
var node = new VariableListNode()
{
Variable = v,
Children = new List <VariableListNode>(),
Parent = parent
};
var vars = v.GetEditableVariables();
if (vars != null)
{
for (var i = 0; i < vars.Count; i++)
{
node.Children.Add(AddListViewItems(vars[i], node, i));
}
}
return(node);
}
public override CVariable SetValue(object val)
{
this.IsSerialized = true;
switch (val)
{
case CVariantSizeNameType var:
var context = new CR2WCopyAction()
{
DestinationFile = this.cr2w,
Parent = this.ParentVar as CVariable
};
this.Variant = var.Variant.Copy(context);
this.SetREDName(var.REDName);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(this);
}
public static void WriteVariable(BinaryWriter file, IEditableVariable ivar)
{
if (ivar is CVariable cvar)
{
file.Write(cvar.GetnameId());
file.Write(cvar.GettypeId());
var pos = file.BaseStream.Position;
file.Write((uint)0); // size placeholder
cvar.Write(file);
var endpos = file.BaseStream.Position;
file.Seek((int)pos, SeekOrigin.Begin);
var actualsize = (uint)(endpos - pos);
file.Write(actualsize); // Write size
file.Seek((int)endpos, SeekOrigin.Begin);
}
else
{
throw new SerializationException();
}
}
public void CreatePropertyLayout(IEditableVariable v)
{
if (EditObject != v)
{
EditObject = v;
if (v == null)
{
treeView.Roots = null;
return;
}
var root = AddListViewItems(v);
treeView.Roots = root.Children;
treeView.RefreshObjects(root.Children);
for (var depth = 0; ExpandOneLevel(depth, root.Children); depth++)
{
}
}
}
