public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
base.OnReadFromXmlNode(reader, node);
XmlNodeList nodes = node.SelectNodes(string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}/{1}", XML_EVENTS, XmlTags.XML_Item));
if (nodes != null && nodes.Count > 0)
{
_events = new List <EventIcon>();
foreach (XmlNode eNode in nodes)
{
EventIcon ei = new EventIcon(this);
ei.ReadFromXmlNode((XmlObjectReader)reader, eNode);
_events.Add(ei);
}
}
//
_inPortList = new List <EventPortIn>();
XmlNodeList nds = node.SelectNodes(string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}/{1}", XML_INPORTS, XmlTags.XML_Item));
foreach (XmlNode n in nds)
{
EventPortIn pi = new EventPortIn(this);
pi.OnReadFromXmlNode(reader, n);
_inPortList.Add(pi);
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlNodeList ns = node.SelectNodes(XML_Item);
foreach (XmlNode nd in ns)
{
if (nd.Attributes != null)
{
XmlAttribute xa = nd.Attributes[XMLATT_name];
if (xa != null)
{
string key = xa.Value;
if (!string.IsNullOrEmpty(key))
{
PropertyValueLinker lk;
if (_properties.TryGetValue(key, out lk))
{
object vl = Activator.CreateInstance(VPLUtil.PropertyValueLinkType, _holder, key);
serializer.ReadObjectFromXmlNode(nd, vl, VPLUtil.PropertyValueLinkType, this);
lk.Linker = vl as IPropertyValueLink;
}
}
}
}
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
_action.ActionMethod = this;
_dataTransfers = new Dictionary <IProperty, ParameterValue>();
XmlNodeList nds = node.SelectNodes(XmlTags.XML_Item);
if (nds != null)
{
foreach (XmlNode item in nds)
{
XmlNode pNode = item.SelectSingleNode(XmlTags.XML_PROPERTY);
if (pNode != null)
{
IProperty p = (IProperty)serializer.ReadObject(pNode, this);
AddProperty(p);
ParameterValue pv = _dataTransfers[p];
XmlNode vNode = item.SelectSingleNode(XmlTags.XML_Data);
if (vNode != null)
{
serializer.ReadObjectFromXmlNode(vNode, pv, typeof(ParameterValue), this);
}
}
}
}
}
public void LoadPorts(XmlNode node)
{
object v;
XmlNodeList nds = node.SelectNodes(XmlSerialization.XML_PORT);
List <LinkLineNodeOutPort> outports = new List <LinkLineNodeOutPort>();
if (nds != null)
{
IXmlCodeReader r = GetReader();
foreach (XmlNode nd in nds)
{
v = XmlSerialization.ReadFromXmlNode(r, nd, this);
if (v != null)
{
if (v is LinkLineNodeInPort)
{
InPort = (LinkLineNodeInPort)v;
}
else if (v is LinkLineNodeOutPort)
{
outports.Add((LinkLineNodeOutPort)v);
}
}
}
}
LinkLineNodeOutPort[] o = new LinkLineNodeOutPort[outports.Count];
outports.CopyTo(o);
OutPorts = o;
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
ServiceName = XmlUtil.GetAttribute(node, XMLATT_ServiceName);
BasePort = XmlUtil.GetAttributeInt(node, XMLATT_ServicePort);
WsHttpPort = XmlUtil.GetAttributeInt(node, XMLATT_wsPort);
TcpPort = XmlUtil.GetAttributeInt(node, XMLATT_tcpPort);
}
public virtual void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
object v;
_name = XmlSerialization.GetAttribute(node, XmlSerialization.XMLATT_NAME);
_static = XmlSerialization.GetAttributeBool(node, XmlSerialization.XMLATT_STATIC);
MakeUIThreadSafe = XmlSerialization.GetAttributeBool(node, XmlSerialization.XMLATT_UIThreadSafe);
if (XmlSerialization.ReadValueFromChildNode(node, XmlSerialization.XML_DESCRIPT, out v))
{
_desc = (string)v;
}
XmlNode nd = node.SelectSingleNode(XmlSerialization.XML_RETURNTYPE);
if (nd != null)
{
_returnType = (RaisDataType)XmlSerialization.ReadFromXmlNode(serializer, nd);
}
else
{
_returnType = new RaisDataType(typeof(double));
}
string qry = XmlSerialization.FormatString("{0}/{1}", XmlSerialization.XML_PARAMLIST, XmlSerialization.XML_PARAM);
XmlNodeList nodes = node.SelectNodes(qry);
if (nodes != null && nodes.Count > 0)
{
_parameters = new Parameter[nodes.Count];
for (int i = 0; i < nodes.Count; i++)
{
_parameters[i] = (Parameter)XmlSerialization.ReadFromXmlNode(serializer, nodes[i]);
}
}
this.MethodID = XmlSerialization.GetAttributeUInt(node, XmlSerialization.XMLATT_ID);
}
public virtual void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
ObjectXmlReader xr = new ObjectXmlReader();
Point l;
if (xr.ReadValueFromChildNode <Point>(node, XML_Location, out l))
{
_location = l;
}
else
{
_location = this.Location;
}
if (NeedSaveSize)
{
Size s;
if (xr.ReadValueFromChildNode <Size>(node, XML_Size, out s))
{
this.Size = s;
}
}
if (_location.X < 0)
{
_location.X = 0;
}
if (_location.Y < 0)
{
_location.Y = 0;
}
this.Location = _location;
}
public void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
MethodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_MethodID);
BranchId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ActionID);
ParameterName = XmlUtil.GetAttribute(node, XmlTags.XMLATT_NAME);
ParameterId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ParamId);
}
public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
if (Method == null)
{
UInt32 id = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ScopeId);
ClassPointer root = ((XmlObjectReader)reader).ObjectList.GetTypedData <ClassPointer>();
if (root != null)
{
Dictionary <string, PropertyClass> props = root.CustomProperties;
foreach (PropertyClass p in props.Values)
{
if (p.Setter != null)
{
if (p.Setter.MemberId == id)
{
init(p.Setter);
break;
}
}
}
}
}
if (!IsValid)
{
throw new DesignerException("Invalid PropertyValueClass");
}
}
public static IXmlNodeSerializable ReadFromXmlNode(IXmlCodeReader serializer, XmlNode node, params object[] constructorParams)
{
if (node == null)
{
throw new XmlSerializationException("Cannot call ReadFromXmlNode with a null node");
}
Type t = XmlUtil.GetLibTypeAttribute(node);
if (t == null)
{
throw new XmlSerializationException(string.Format("Xml node {0} having an invalid type attribute: {1}. Check the version of the DLL providing the type.", node.Name, XmlUtil.GetLibTypeAttributeString(node)));
}
try
{
if (t.Equals(typeof(ObjectRef)))
{
constructorParams = new object[] { node };
}
IXmlNodeSerializable obj = (IXmlNodeSerializable)Activator.CreateInstance(t, constructorParams);
obj.OnReadFromXmlNode(serializer, node);
return(obj);
}
catch (Exception e)
{
XmlSerializationException er = new XmlSerializationException(string.Format("Xml node {0} with {1} as type attribute cannot create an IXmlNodeSerializable object. See the inner exception for details.", node.Name, XmlUtil.GetLibTypeAttributeString(node)), e);
throw er;
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
_instanceType = serializer.ReadValue <Type>(node, null);
if (_instanceType == null)
{
string msg = node.InnerXml;
throw new VPLException("Loading type failed from xml [{0}]. If this project was developed in another Limnor Studio IDE then it could be that some support files or dependent assemblies are not copied from the original IDE", msg);
}
SetType(_instanceType, serializer.ProjectFolder);
XmlNode dataNode = node.SelectSingleNode(XML_Data);
if (dataNode != null)
{
PropertyDescriptorCollection ps = GetProperties();
foreach (XmlNode nd in dataNode.ChildNodes)
{
PropertyDescriptor p = ps[nd.Name];
if (p != null)
{
object obj = serializer.ReadObject(nd, this); //.ReadObjectFromXmlNode(nd, obj, p.PropertyType, this);
p.SetValue(this, obj);
}
}
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
_properties = new SortedList <string, TypedNamedValue>();
XmlNode items = node.SelectSingleNode(XmlTags.XML_Data);
if (items != null)
{
XmlNodeList nds = items.SelectNodes(XmlTags.XML_Item);
foreach (XmlNode nd in nds)
{
string name = XmlUtil.GetNameAttribute(nd);
Type t = XmlUtil.GetLibTypeAttribute(nd);
object v = null;
XmlNode d = nd.SelectSingleNode(XmlTags.XML_Data);
if (d != null)
{
v = serializer.ReadValue(d);
}
_properties.Add(name, new TypedNamedValue(name, new TypedValue(t, v)));
}
}
createFileList();
items = node.SelectSingleNode(XmlTags.XML_External);
if (items != null)
{
StringCollection ss = new StringCollection();
XmlNodeList nds = items.SelectNodes(XmlTags.XML_Item);
foreach (XmlNode nd in nds)
{
string name = XmlUtil.GetNameAttribute(nd);
ss.Add(name);
}
_phpIncludes.SetNames(ss);
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlAttribute xa = node.OwnerDocument.CreateAttribute(XMLATT_name);
xa.Value = _eventName;
node.Attributes.Append(xa);
}
protected virtual void OnRead(IXmlCodeReader reader, XmlNode dataNode)
{
Type t = XmlUtil.GetLibTypeAttribute(dataNode);
if (t != null)
{
if (t.Equals(typeof(ParameterClass)))
{
_type = (DataTypePointer)Activator.CreateInstance(t, Method);
}
else
{
_type = (DataTypePointer)Activator.CreateInstance(t);
}
reader.ReadObjectFromXmlNode(dataNode, _type, t, this);
CreateLocalVariable();
if (_type.IsPrimitive)
{
LocalVariable v = this.LocalPointer;
if (v != null)
{
XmlNode nd = dataNode.SelectSingleNode("Value");
if (nd != null)
{
object val = reader.ReadValue(nd, null, _type.ObjectType);
if (val != null)
{
v.ObjectInstance = val;
}
}
}
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
XmlNode nd = node.SelectSingleNode(XML_VAR);
if (nd != null)
{
MathNodeRoot root = new MathNodeRoot();
root.IsVariableHolder = true;
root[0] = var;
var.Load(nd);
if (var.InPort != null)
{
var.InPort.Owner = this;
var.InPort.Label.Visible = false;
}
if (var.OutPorts != null)
{
LinkLineNodeOutPort[] o = var.OutPorts;
for (int i = 0; i < o.Length; i++)
{
o[i].Owner = this;
}
}
}
this.Size = new Size(32, 32);
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
PropertyId = XmlUtil.GetAttributeUInt(node, XMLATTR_PropertyId);
PropertyClassId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID);
XmlObjectReader reader = (XmlObjectReader)serializer;
if (PropertyClassId == 0)
{
PropertyClassId = reader.ObjectList.ClassId;
}
ClassPointer root = ClassPointer.CreateClassPointer(PropertyClassId, reader.ObjectList.Project);
PropertyClass mc = root.GetCustomPropertyById(PropertyId);
if (mc == null)
{
MathNode.LogError(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"Property {0} not found in class {1}", PropertyId, root.ClassId));
}
else
{
_property = mc;
}
}
public void SetReader(IXmlCodeReader reader)
{
if (reader != null)
{
_reader = reader;
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlNode dataNode = node.SelectSingleNode(XmlTags.XML_Data);
if (dataNode != null)
{
_data = new WebPageDataSet();
_data.ReadFromXmlNode(serializer, dataNode);
//
WebDataTable[] tbls = _data.GetData();
if (tbls != null)
{
for (int i = 0; i < tbls.Length; i++)
{
DataTable dt = new DataTable(tbls[i].TableName);
Tables.Add(dt);
if (tbls[i].Columns != null)
{
for (int j = 0; j < tbls[i].Columns.Length; j++)
{
dt.Columns.Add(tbls[i].Columns[j].ColumnName, tbls[i].Columns[j].SystemType);
}
}
}
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
if (_prop == null)
{
UInt32 id = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ScopeId);
ClassPointer root = ((XmlObjectReader)reader).ObjectList.GetTypedData <ClassPointer>();
if (root != null)
{
List <PropertyClassInherited> props = root.GetPropertyOverrides();
foreach (PropertyClassInherited p in props)
{
if (p.Getter != null)
{
if (p.Getter.MemberId == id)
{
setScope(p.Getter);
break;
}
}
if (p.Setter != null)
{
if (p.Setter.MemberId == id)
{
setScope(p.Setter);
break;
}
}
}
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
_classId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID);
_memberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
XmlNode pn = node.SelectSingleNode(XML_Location);
if (pn != null)
{
this.Location = reader.ReadValue <Point>(pn, this);
}
if (UseLabel)
{
object v;
if (XmlSerialization.ReadValueFromChildNode(node, XML_RelativePosition, out v))
{
if (_label == null)
{
_label = new DrawingLabel(this);
}
_label.RelativePosition.Location = (Point)v;
XmlNode nd = node.SelectSingleNode(XML_RelativePosition);
_label.RelativePosition.IsXto0 = XmlSerialization.GetAttributeBool(nd, "xTo0", true);
_label.RelativePosition.IsYto0 = XmlSerialization.GetAttributeBool(nd, "yTo0", true);
}
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlNodeList ns = node.SelectNodes(XmlTags.XML_Item);
foreach (XmlNode nodeItem in ns)
{
string key = XmlUtil.GetNameAttribute(nodeItem);
if (!string.IsNullOrEmpty(key))
{
if (!this.ContainsKey(key))
{
Type t = XmlUtil.GetLibTypeAttribute(nodeItem);
if (t != null)
{
IJavascriptType v = Activator.CreateInstance(t) as IJavascriptType;
if (v != null)
{
v.OnReadFromXmlNode(serializer, nodeItem);
this.Add(key, v);
}
}
}
}
}
}
public void ReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
TableName = XmlUtil.GetNameAttribute(node);
XmlNodeList ns = node.SelectNodes(string.Format(CultureInfo.InvariantCulture,
"{0}/{1}", XML_Columns, WebPageDataSet.XML_Item));
Columns = new WebDataColumn[ns.Count];
for (int i = 0; i < ns.Count; i++)
{
Columns[i] = new WebDataColumn();
Columns[i].ReadFromXmlNode(ns[i]);
}
Rows = new Dictionary <string, WebPageDataRow[]>();
XmlNodeList ndrcs = node.SelectNodes(string.Format(CultureInfo.InvariantCulture,
"{0}/{1}", XML_Rows, XML_RowsC));
foreach (XmlNode ndc in ndrcs)
{
string culture = XmlUtil.GetAttribute(ndc, XMLATTR_culture);
XmlNodeList nrs = ndc.SelectNodes(WebPageDataSet.XML_Item);
WebPageDataRow[] rs = new WebPageDataRow[nrs.Count];
for (int i = 0; i < nrs.Count; i++)
{
rs[i] = new WebPageDataRow();
rs[i].ReadFromXmlNode(reader, nrs[i]);
}
Rows.Add(culture, rs);
}
}
protected override void OnRead(IXmlCodeReader reader, XmlNode dataNode)
{
CustomMethodReturnPointer v = new CustomMethodReturnPointer();
this.ClassPointer = v;
v.OnReadFromXmlNode(reader, dataNode);
v.SetName(this.GetVariableName());
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
int x = XmlUtil.GetAttributeInt(node, XMLATTR_RELX);
int y = XmlUtil.GetAttributeInt(node, XMLATTR_RELY);
_relativeLocation = new Point(x, y);
}
public override void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
base.OnReadFromXmlNode(reader0, node);
if (_classId == 0)
{
_classId = reader.ObjectList.ClassId;
}
ActionId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ActionID);
if (base.Method == null)
{
IAction a = null;
if (reader0.ObjectStack != null)
{
if (reader0.ObjectStack.Count > 0)
{
IEnumerator ie = reader0.ObjectStack.GetEnumerator();
while (ie.MoveNext())
{
a = ie.Current as IAction;
if (a != null)
{
if (a.ActionId == ActionId)
{
base.Method = a.ActionMethod.MethodPointed;
break;
}
}
}
}
}
if (base.Method == null)
{
if (reader.ObjectStack != null && reader.ObjectStack.Count > 0)
{
IEnumerator ie = reader.ObjectStack.GetEnumerator();
while (ie.MoveNext())
{
IActionsHolder actsHolder = ie.Current as IActionsHolder;
if (actsHolder != null)
{
a = actsHolder.TryGetActionInstance(ActionId);
if (a != null)
{
base.Method = a.ActionMethod.MethodPointed;
break;
}
}
}
}
}
}
if (base.Method == null)
{
reader0.AddPostOwnersDeserializers(this);
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlNode psNode = node.SelectSingleNode(XML_QryParams);
if (psNode != null)
{
_links.OnReadFromXmlNode(serializer, psNode);
}
}
public virtual void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
_exp = new MathNodeRoot();
_hasData = XmlUtil.GetAttributeBoolDefFalse(node, XMLATT_HasData);
if (_hasData)
{
_exp.OnReadFromXmlNode(reader, node);
}
}
public void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_PROPERTY);
if (nd != null)
{
_valuePointer = (IObjectPointer)reader.ReadObject(nd, null);
}
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
XmlNode data = node.SelectSingleNode(XmlTags.XML_Data);
if (data != null)
{
_value = serializer.ReadObject(data, this);
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
XmlNode collectionTypeNode = node.SelectSingleNode(XML_CollectionType);
if (collectionTypeNode != null)
{
_collectionType = XmlUtil.GetLibTypeAttribute(collectionTypeNode);
}
base.OnReadFromXmlNode(reader, node);
}
