/// <summary>
/// it must be called from a separated app domain other than the designer.
/// </summary>
/// <param name="xmlFile"></param>
public void Load(string xmlFile)
{
ProjectEnvironment.RunMode = true;
XmlDocument doc = new XmlDocument();
doc.Load(xmlFile);
XmlNode _node = doc.DocumentElement;
LimnorProject project = new LimnorProject(LimnorProject.GetProjectFileByComponentFile(xmlFile));
//create root object
UInt32 classId = XmlUtil.GetAttributeUInt(_node, XmlTags.XMLATT_ClassID);
UInt32 memberId = XmlUtil.GetAttributeUInt(_node, XmlTags.XMLATT_ComponentID);
ObjectIDmap map = new ObjectIDmap(project, DesignUtil.MakeDDWord(memberId, classId), _node);
XmlObjectReader xr = new XmlObjectReader(map, ClassPointer.OnAfterReadRootComponent, ClassPointer.OnRootComponentCreated);
map.SetReader(xr);
_rootId = new ClassPointer(classId, memberId, map, null);
string file = project.GetComponentFileByClassId(classId);
ComponentLoader loader = new ComponentLoader(xr, file);
DesignSurface ds = new DesignSurface();
ds.BeginLoad(loader);
if (xr.Errors != null && xr.Errors.Count > 0)
{
MathNode.Log(xr.Errors);
}
_rootId.LoadActionInstances();
}
public void OnPostSerialize(XmlSerializer.ObjectIDmap objMap, System.Xml.XmlNode objectNode, bool saved, object serializer)
{
if (saved)
{
}
else
{
if (_pointer == null && _memberPointer == null)
{
XmlNode node = SerializeUtil.GetClassRefNodeByObjectId(objectNode, _memberId);
if (node != null)
{
XmlObjectReader xr = (XmlObjectReader)serializer;
_pointer = xr.ReadObject <ClassInstancePointer>(node, ClassPointer.CreateClassPointer(objMap));
//_pointer.ObjectInstance = objMap.GetObjectByID(_pointer.MemberId);
}
else
{
_pointer = objMap.GetClassRefById(_memberId) as ClassInstancePointer;
}
}
if (_pointer == null)
{
object v = objMap.GetObjectByID(_memberId);
if (v != null)
{
_memberPointer = new MemberComponentId(objMap.GetTypedData <ClassPointer>(), v, _memberId);
}
}
if (_pointer == null && _memberPointer == null)
{
objMap.AddPostProcessor(this);
}
}
}
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 OnBeforeRead(XmlObjectReader reader, XmlNode node)
{
_reader = reader;
_xmlNode = node;
ScopeMethodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ScopeId);
SubScopeId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_SubScopeId);
}
public virtual void OnBeforeRead(XmlObjectReader reader, XmlNode node)
{
_reading = true;
_xmlNode = node;
_reader = reader;
_actId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ActionID);
}
public void OnDelayedPostSerialize(ObjectIDmap objMap, XmlNode objectNode, XmlObjectReader reader)
{
if (_prj == null)
{
_prj = objMap.Project;
}
resolveDataType();
}
public void LoadCustomPropertyValues(XmlObjectReader reader, XmlNode objectNode)
{
if (_properties != null)
{
PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(_properties.ToArray());
reader.ReadProperties(objectNode, this, pdc, XmlTags.XML_PROPERTY);
}
}
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);
}
}
protected override void OnLoad(XmlNode node)
{
XmlObjectReader xr = this.root.Reader as XmlObjectReader;
if (xr != null)
{
OnReadFromXmlNode(xr, node);
}
}
public void ReadFromXmlNode(XmlObjectReader reader, XmlNode node)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_Property);
if (nd != null)
{
_valuePointer = (IObjectPointer)reader.ReadObject(nd, null);
}
}
public virtual void OnPostSerialize(ObjectIDmap objMap, XmlNode objectNode, bool saved, object serializer)
{
if (BaseClassType != null)
{
if (BaseClassType.IsGenericParameter || BaseClassType.IsGenericType)
{
XmlObjectReader xr = serializer as XmlObjectReader;
if (xr != null)
{
if (xr.ObjectStack.Count > 0)
{
DataTypePointer dp = null;
IEnumerator ie = xr.ObjectStack.GetEnumerator();
while (ie.MoveNext())
{
if (ie.Current != this)
{
ActionClass act = ie.Current as ActionClass;
if (act != null)
{
dp = act.GetConcreteType(this.BaseClassType);
if (dp != null)
{
break;
}
}
else
{
MethodClass mc = ie.Current as MethodClass;
if (mc != null)
{
dp = mc.GetConcreteType(this.BaseClassType);
if (dp != null)
{
break;
}
}
}
}
}
if (dp != null)
{
if (BaseClassType.IsGenericParameter)
{
_type.SetConcreteType(dp);
}
else
{
_type.TypeParameters = dp.TypeParameters;
}
}
}
}
}
}
}
public static IXmlCodeWriter CreateWriterFromReader(IXmlCodeReader reader)
{
XmlObjectReader r = reader as XmlObjectReader;
if (r != null && r.ObjectList != null)
{
return(new XmlObjectWriter(r.ObjectList));
}
return(XmlSerializerUtility.ActiveWriter);
}
public void PushValues(TIn input, Action <TOut> push)
{
using (var s = _args.DataStreamSelector(input))
{
var xmlFileDefinition = new XmlFileDefinition()
.AddNodeDefinition(_args.XmlNodeDefinition)
.AddNameSpaces(_args.PrefixToUriNamespaces);
XmlObjectReader xmlObjectReader = new XmlObjectReader(xmlFileDefinition);
xmlObjectReader.Read(s, i => push(_args.ResultSelector(input, i.GetValue <TParsed>())));
}
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
_classId = XmlUtil.GetAttributeUInt(node, XMLATT_ownerClassId);
XmlObjectReader r = serializer as XmlObjectReader;
if (r != null)
{
_classPointer = ClassPointer.CreateClassPointer(_classId, r.ObjectList.Project);
}
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
XmlNode eNode = node.SelectSingleNode(XML_Event);
XmlObjectReader reader = (XmlObjectReader)serializer;
_event = (IEvent)reader.ReadObject(eNode, null);
int x = XmlUtil.GetAttributeInt(node, XMLATTR_RELX);
int y = XmlUtil.GetAttributeInt(node, XMLATTR_RELY);
_relativeLocation = new Point(x, y);
}
public void DeserializeRawData([ValueSource(typeof(Resources), nameof(Resources.ObjectStreams))] ResourceData <Stream> data)
{
using (data.Data) {
XmlObjectReader reader = new XmlObjectReader(data.Data);
while (reader.ContainsData)
{
XmlDocument document = reader.Read();
Assert.NotNull(document, "No document read");
}
Assert.AreEqual(data.Data.Position, data.Data.Length, "Bytes left in stream");
}
}
public void OnBeforeRead(XmlObjectReader reader, XmlNode node)
{
_reader = reader;
_xmlNode = node;
ScopeMethodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ScopeId);
SubScopeId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_SubScopeId);
_varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
//load DataTypePointer from ComponentIconLocal
ClassPointer root = reader.ObjectList.GetTypedData <ClassPointer>();
_var = root.GetLocalVariable(_varId);
adjustParamType();
}
protected override void OnLoad(XmlNode node)
{
XmlObjectReader xr = this.root.Serializer as XmlObjectReader;
if (xr != null)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_Property);
if (nd != null)
{
// ObjectIDmap map = (ObjectIDmap)XmlObjectReader.GetService(typeof(ObjectIDmap));
// XmlObjectReader xr = new XmlObjectReader(map);
_valuePointer = (IObjectPointer)xr.ReadObject(nd, null);
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
string refName = XmlUtil.GetAttribute(node, XML_ATTR_DataSource);
if (!string.IsNullOrEmpty(refName))
{
XmlObjectReader xr = serializer as XmlObjectReader;
if (xr != null)
{
xr.AddDelayedInitializer(this, node);
}
}
if (XmlUtil.HasAttribute(node, XML_ATTR_dispStyle))
{
_displayStyle = XmlUtil.GetAttribute(node, XML_ATTR_dispStyle);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_rcount))
{
_rowCount = XmlUtil.GetAttributeInt(node, XML_ATTR_rcount);
}
IsRepeaterHolder = XmlUtil.GetAttributeBoolDefFalse(node, XML_ATTR_repeater);
if (XmlUtil.HasAttribute(node, XML_ATTR_ccount))
{
_columnCount = XmlUtil.GetAttributeInt(node, XML_ATTR_ccount);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_autoCR))
{
_autoColRow = XmlUtil.GetAttributeBoolDefTrue(node, XML_ATTR_autoCR);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_showall))
{
_showAllRecs = XmlUtil.GetAttributeBoolDefFalse(node, XML_ATTR_showall);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_pagenum))
{
_pnp = XmlUtil.GetAttributeInt(node, XML_ATTR_pagenum);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_pageloc))
{
_navigatorLocation = XmlUtil.GetAttributeEnum <EnumPageNavigatorPosition>(node, XML_ATTR_pageloc);
}
if (XmlUtil.HasAttribute(node, XML_ATTR_pnfont))
{
_navigateFont = XmlUtil.GetAttributeFont(node, XML_ATTR_pnfont);
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
base.OnReadFromXmlNode(reader0, node);
XmlObjectReader reader = (XmlObjectReader)reader0;
_prj = reader.ObjectList.Project;
_root = reader.ObjectList.RootPointer as ClassPointer;
ClassPointer cp = OwnerClassPointer;
if (cp != null)
{
this.ClassPointer = cp;
SetLabelText(cp.Name);
OnSetImage();
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
base.OnReadFromXmlNode(reader, node);
string guid = XmlUtil.GetAttribute(node, XmlTags.XMLATT_guid);
XmlObjectReader xr = reader as XmlObjectReader;
ClassPointer root = xr.ObjectList.RootPointer as ClassPointer;
HtmlElement_Base he = null;
if (!string.IsNullOrEmpty(guid))
{
he = root.FindHtmlElementByGuid(new Guid(guid));
}
if (he == null)
{
he = new HtmlElement_body(root);
}
this.ClassPointer = he;
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
MethodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_handlerId);
XmlObjectReader reader = (XmlObjectReader)serializer;
ClassPointer root = reader.ObjectList.RootPointer as ClassPointer;
MethodClass mc = root.GetCustomMethodById(MethodId);
if (mc == null)
{
MathNode.LogError(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"Method {0} not found in class {1}", MethodId, root.ClassId));
}
else
{
_method = mc;
}
}
protected override void OnRead(IXmlCodeReader reader, XmlNode node)
{
_methodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_MethodID);
string s = XmlUtil.GetNameAttribute(node);
if (!string.IsNullOrEmpty(s))
{
this.SetName(s);
}
if (_prj == null)
{
XmlObjectReader r = reader as XmlObjectReader;
if (r != null && r.ObjectList != null)
{
_prj = r.ObjectList.Project;
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
_parameters = null;
XmlObjectReader reader = (XmlObjectReader)reader0;
ClassId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID);
XmlNodeList nds = node.SelectNodes(string.Format(CultureInfo.InvariantCulture,
"{0}/{1}", XmlTags.XML_PARAMLIST, XmlTags.XML_Item));
if (nds != null)
{
_parameters = new List <NamedDataType>();
foreach (XmlNode itemNode in nds)
{
NamedDataType ndt = new NamedDataType();
ndt.OnReadFromXmlNode(reader, itemNode);
_parameters.Add(ndt);
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
base.OnReadFromXmlNode(reader0, node);
XmlObjectReader reader = (XmlObjectReader)reader0;
_prj = reader.ObjectList.Project;
_root = reader.ObjectList.RootPointer as ClassPointer;
XmlNode nd = node.SelectSingleNode(XML_Type);
if (nd != null)
{
Type t = XmlUtil.GetLibTypeAttribute(nd);
if (t != null)
{
this.ClassPointer = new DataTypePointer(new TypePointer(t));
SetLabelText(t.Name);
OnSetImage();
}
}
}
public void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
_conditionWidth = XmlUtil.GetAttributeInt(node, XMLATT_colWidth);
_actionWidth = XmlUtil.GetAttributeInt(node, XMLATT_col2Width);
int w = XmlUtil.GetAttributeInt(node, XMLATT_width);
if (w > 100)
{
_editorSize.Width = w;
}
w = XmlUtil.GetAttributeInt(node, XMLATT_height);
if (w > 100)
{
_editorSize.Height = w;
}
_decisionTable = new List <DecisionItem>();
XmlNodeList itemsNodes = node.SelectNodes(XmlTags.XML_Item);
foreach (XmlNode item in itemsNodes)
{
XmlNode nodeCOndition = item.SelectSingleNode(XML_Condition);
if (nodeCOndition != null)
{
ActionList acts = new ActionList();
MathNodeRoot r = (MathNodeRoot)reader.ReadValue(nodeCOndition, this);
XmlNode nodeActions = item.SelectSingleNode(XmlTags.XML_ACTIONS);
if (nodeActions != null)
{
acts.OnReadFromXmlNode((XmlObjectReader)reader, nodeActions);
}
_decisionTable.Add(new DecisionItem(r, acts));
}
else
{
reader.addErrStr2("Decision table missing condition node");
}
}
}
protected override void OnLoad(XmlNode node)
{
MathNodeRoot r = this.root;
if (r != null)
{
XmlObjectReader xr = r.Reader as XmlObjectReader;
if (xr != null)
{
XmlNode nodeMethod = node.SelectSingleNode(XmlSerialization.XML_METHOD);
if (nodeMethod != null)
{
_methodPointer = (IActionMethodPointer)xr.ReadObject(nodeMethod, null);
_id = XmlUtil.GetAttributeUInt(nodeMethod, XmlTags.XMLATT_NodeId);
InitializeChildren();
}
}
else
{
throw new DesignerException("Reader not available calling MathNodeMethodPointer.OnLoad");
}
}
}
protected virtual void loadEventAction()
{
if (_eventAction == null)
{
//it is public because event-handler does not belong to the scope method of this action branch.
XmlNode node = _class.XmlData.SelectSingleNode(string.Format(CultureInfo.InvariantCulture,
"{0}/{1}[@{2}='{3}']",
XmlTags.XML_HANDLERLISTS, XmlTags.XML_HANDLER, XmlTags.XMLATT_ActionID, this.ActionId));
if (node != null)
{
Guid g = Guid.NewGuid();
XmlObjectReader xr = _class.ObjectList.Reader;
xr.ResetErrors();
xr.ClearDelayedInitializers(g);
_eventAction = (EventAction)xr.ReadObject(node, null);
xr.OnDelayedInitializeObjects(g);
if (xr.Errors != null && xr.Errors.Count > 0)
{
MathNode.Log(xr.Errors);
}
}
}
}
protected override void OnLoad(XmlNode node)
{
_value = XmlUtil.GetAttribute(node, XmlTags.XMLATT_NAME);
if (string.IsNullOrEmpty(_value))
{
_value = "x";
}
_subscript = XmlUtil.GetAttribute(node, XMLATT_Subcript);
_id = XmlUtil.GetAttributeInt(node, XmlTags.XMLATT_VARID);
if (_id == 0)
{
_id = Guid.NewGuid().GetHashCode();
}
XmlObjectReader xr = this.root.Serializer as XmlObjectReader;
if (xr != null)
{
XmlNode nd = node.SelectSingleNode(XML_ValueType);
if (nd != null)
{
_dataType = (DataTypePointer)xr.ReadObject(nd, null);
}
}
}
public void SetReader(XmlObjectReader reader)
{
_reader = reader;
}
