private TreeNode RecursiveCloning(TreeNode node)
{
var newComp = (IPBComposite)(((IPBComposite)node.Tag).Clone());
var newNode = new TreeNode(newComp.Title)
{
ForeColor = newComp.Color, Tag = newComp
};
foreach (TreeNode child in node.Nodes)
{
// If, While and SubRoutine are Decorators.
var groupComposite = newComp as GroupComposite;
if (groupComposite != null)
{
GroupComposite gc = groupComposite;
TreeNode newChildNode = RecursiveCloning(child);
gc.AddChild((Composite)newChildNode.Tag);
newNode.Nodes.Add(newChildNode);
}
}
return(newNode);
}
TreeNode RecursiveCloning(TreeNode node)
{
IPBComposite newComp = (IPBComposite)(((IPBComposite)node.Tag).Clone());
TreeNode newNode = new TreeNode(newComp.Title);
newNode.ForeColor = newComp.Color;
newNode.Tag = newComp;
if (node.Nodes != null)
{
foreach (TreeNode child in node.Nodes)
{
GroupComposite gc = null;
// If, While and SubRoutine are Decorators.
if (newComp is GroupComposite)
{
gc = (GroupComposite)newComp;
TreeNode newChildNode = RecursiveCloning(child);
gc.AddChild((Composite)newChildNode.Tag);
newNode.Nodes.Add(newChildNode);
}
}
}
return newNode;
}
private GroupComposite Load(XElement xml, GroupComposite comp)
{
foreach (XNode node in xml.Nodes())
{
if (node.NodeType == XmlNodeType.Comment)
{
comp.AddChild(new Comment(((XComment)node).Value));
}
else if (node.NodeType == XmlNodeType.Element)
{
var element = (XElement)node;
Type type = Type.GetType("HighVoltz.Composites." + element.Name);
if (type == null)
{
IEnumerable <Type> pbTypes = from t in Assembly.GetExecutingAssembly().GetTypes()
where (typeof(IPBComposite)).IsAssignableFrom(t) && !t.IsAbstract
select t;
type =
pbTypes.FirstOrDefault(
t =>
t.GetCustomAttributes(typeof(XmlRootAttribute), true).Any(
a => ((XmlRootAttribute)a).ElementName == element.Name));
if (type == null)
{
throw new InvalidOperationException(
string.Format("Unable to bind XML Element: {0} to a Type", element.Name));
}
}
var pbComp = (IPBComposite)Activator.CreateInstance(type);
pbComp.OnProfileLoad(element);
var pbXmlAttrs = from pi in type.GetProperties()
from attr in
(PbXmlAttributeAttribute[])
pi.GetCustomAttributes(typeof(PbXmlAttributeAttribute), true)
where attr != null
let name = attr.AttributeName ?? pi.Name
select new { name, pi };
Dictionary <string, PropertyInfo> piDict = pbXmlAttrs.ToDictionary(kv => kv.name, kv => kv.pi);
Dictionary <string, string> attributes = element.Attributes().ToDictionary(k => k.Name.ToString(),
v => v.Value);
// use legacy X,Y,Z location for backwards compatability
if (attributes.ContainsKey("X"))
{
string location = string.Format("{0},{1},{2}", attributes["X"], attributes["Y"], attributes["Z"]);
piDict["Location"].SetValue(pbComp, location, null);
attributes.Remove("X");
attributes.Remove("Y");
attributes.Remove("Z");
}
foreach (var attr in attributes)
{
if (piDict.ContainsKey(attr.Key))
{
PropertyInfo pi = piDict[attr.Key];
// check if there is a type converter attached
var typeConverterAttr =
(TypeConverterAttribute)
pi.GetCustomAttributes(typeof(TypeConverterAttribute), true).FirstOrDefault();
if (typeConverterAttr != null)
{
try
{
var typeConverter =
(TypeConverter)
Activator.CreateInstance(Type.GetType(typeConverterAttr.ConverterTypeName));
if (typeConverter.CanConvertFrom(typeof(string)))
{
pi.SetValue(pbComp,
typeConverter.ConvertFrom(null, CultureInfo.CurrentCulture,
attr.Value), null);
}
else
{
Professionbuddy.Err("The TypeConvert {0} can not convert from string.",
typeConverterAttr.ConverterTypeName);
}
}
catch (Exception ex)
{
Professionbuddy.Err("Type conversion for {0} has failed.\n{1}", type.Name + attr.Key,
ex);
}
}
else
{
pi.SetValue(pbComp,
pi.PropertyType.IsEnum
? Enum.Parse(pi.PropertyType, attr.Value)
: Convert.ChangeType(attr.Value, pi.PropertyType), null);
}
}
else
{
Professionbuddy.Log("{0}->{1} appears to be unused", type, attr.Key);
}
}
if (pbComp is GroupComposite)
{
Load(element, pbComp as GroupComposite);
}
comp.AddChild((Composite)pbComp);
}
}
return(comp);
}
private GroupComposite Load(XElement xml, GroupComposite comp)
{
foreach (XNode node in xml.Nodes())
{
if (node.NodeType == XmlNodeType.Comment)
{
comp.AddChild(new Comment(((XComment) node).Value));
}
else if (node.NodeType == XmlNodeType.Element)
{
var element = (XElement) node;
Type type = Type.GetType("HighVoltz.Composites." + element.Name);
if (type == null)
{
IEnumerable<Type> pbTypes = from t in Assembly.GetExecutingAssembly().GetTypes()
where (typeof (IPBComposite)).IsAssignableFrom(t) && !t.IsAbstract
select t;
type =
pbTypes.FirstOrDefault(
t =>
t.GetCustomAttributes(typeof (XmlRootAttribute), true).Any(
a => ((XmlRootAttribute) a).ElementName == element.Name));
if (type == null)
throw new InvalidOperationException(
string.Format("Unable to bind XML Element: {0} to a Type", element.Name));
}
var pbComp = (IPBComposite) Activator.CreateInstance(type);
pbComp.OnProfileLoad(element);
var pbXmlAttrs = from pi in type.GetProperties()
from attr in
(PbXmlAttributeAttribute[])
pi.GetCustomAttributes(typeof (PbXmlAttributeAttribute), true)
where attr != null
let name = attr.AttributeName ?? pi.Name
select new {name, pi};
Dictionary<string, PropertyInfo> piDict = pbXmlAttrs.ToDictionary(kv => kv.name, kv => kv.pi);
Dictionary<string, string> attributes = element.Attributes().ToDictionary(k => k.Name.ToString(),
v => v.Value);
// use legacy X,Y,Z location for backwards compatability
if (attributes.ContainsKey("X"))
{
string location = string.Format("{0},{1},{2}", attributes["X"], attributes["Y"], attributes["Z"]);
piDict["Location"].SetValue(pbComp, location, null);
attributes.Remove("X");
attributes.Remove("Y");
attributes.Remove("Z");
}
foreach (var attr in attributes)
{
if (piDict.ContainsKey(attr.Key))
{
PropertyInfo pi = piDict[attr.Key];
// check if there is a type converter attached
var typeConverterAttr =
(TypeConverterAttribute)
pi.GetCustomAttributes(typeof (TypeConverterAttribute), true).FirstOrDefault();
if (typeConverterAttr != null)
{
try
{
var typeConverter =
(TypeConverter)
Activator.CreateInstance(Type.GetType(typeConverterAttr.ConverterTypeName));
if (typeConverter.CanConvertFrom(typeof (string)))
{
pi.SetValue(pbComp,
typeConverter.ConvertFrom(null, CultureInfo.InvariantCulture,
attr.Value), null);
}
else
Professionbuddy.Err("The TypeConvert {0} can not convert from string.",
typeConverterAttr.ConverterTypeName);
}
catch (Exception ex)
{
Professionbuddy.Err("Type conversion for {0} has failed.\n{1}", type.Name + attr.Key,
ex);
}
}
else
{
pi.SetValue(pbComp,
pi.PropertyType.IsEnum
? Enum.Parse(pi.PropertyType, attr.Value)
: Convert.ChangeType(attr.Value, pi.PropertyType, CultureInfo.InvariantCulture), null);
}
}
else
Professionbuddy.Log("{0}->{1} appears to be unused", type, attr.Key);
}
if (pbComp is GroupComposite)
Load(element, pbComp as GroupComposite);
comp.AddChild((Composite) pbComp);
}
}
return comp;
}
void AddToActionTree(object action, TreeNode dest)
{
bool ignoreRoot = (copyAction & CopyPasteOperactions.IgnoreRoot) == CopyPasteOperactions.IgnoreRoot ? true : false;
bool cloneActions = (copyAction & CopyPasteOperactions.Copy) == CopyPasteOperactions.Copy ? true : false;
TreeNode newNode = null;
if (action is TreeNode)
{
if (cloneActions)
{
newNode = RecursiveCloning(((TreeNode)action));
}
else
newNode = (TreeNode)((TreeNode)action).Clone();
}
else if (action.GetType().GetInterface("IPBComposite") != null)
{
IPBComposite composite = (IPBComposite)action;
newNode = new TreeNode(composite.Title);
newNode.ForeColor = composite.Color;
newNode.Tag = composite;
}
else
return;
ActionTree.SuspendLayout();
if (dest != null)
{
int treeIndex = action is TreeNode && ((TreeNode)action).Parent == dest.Parent &&
((TreeNode)action).Index <= dest.Index && !cloneActions ?
dest.Index + 1 : dest.Index;
GroupComposite gc = null;
// If, While and SubRoutines are Decorators...
if (!ignoreRoot && dest.Tag is GroupComposite)
gc = (GroupComposite)dest.Tag;
else
gc = (GroupComposite)((Composite)dest.Tag).Parent;
if ((dest.Tag is If || dest.Tag is SubRoutine) && !ignoreRoot)
{
dest.Nodes.Add(newNode);
gc.AddChild((Composite)newNode.Tag);
if (!dest.IsExpanded)
dest.Expand();
}
else
{
if (dest.Index >= gc.Children.Count)
gc.AddChild((Composite)newNode.Tag);
else
gc.InsertChild(dest.Index, (Composite)newNode.Tag);
if (dest.Parent == null)
{
if (treeIndex >= ActionTree.Nodes.Count)
ActionTree.Nodes.Add(newNode);
else
ActionTree.Nodes.Insert(treeIndex, newNode);
}
else
{
if (treeIndex >= dest.Parent.Nodes.Count)
dest.Parent.Nodes.Add(newNode);
else
dest.Parent.Nodes.Insert(treeIndex, newNode);
}
}
}
else
{
ActionTree.Nodes.Add(newNode);
PB.CurrentProfile.Branch.AddChild((Composite)newNode.Tag);
}
ActionTree.ResumeLayout();
}