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 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 UserControlDebugger(LimnorDebugger debugger)
: base()
{
_threadData = new Dictionary <int, ThreadDebug>();
_debugger = debugger;
//
miSetSelectedObject = new fnOnObject(setSelectedObj);
miShowBreakPointInMethod = new fnShowBreakPointInMethod(showBreakPointInMethod);
miClearBreakPointInMethod = new fnShowBreakPointInMethod(clearBreakPointInMethod);
miShowActiveControl = new fnOnControl(showActiveControl0);
//
InitializeComponent();
//
//
_rootClassId = ClassPointer.CreateClassPointer(_debugger.Project, _debugger.RootXmlNode);
_classId = _rootClassId.ClassId;
_rootClassId.LoadActions(_rootClassId);
_methods = _rootClassId.CustomMethods;
_designer = new MethodDebugDesigner(_rootClassId, _debugger.Project);
TreeNodeClassRoot r = treeView1.CreateClassRoot(true, _rootClassId, false);
treeView1.Nodes.Add(r);
treeView1.GotFocus += new EventHandler(treeView1_GotFocus);
//
}
public void GetParameters(string projectFile, string classFile)
{
bool loadedHere = false;
LimnorProject _project = new LimnorProject(projectFile);
XmlDocument doc = new XmlDocument();
doc.Load(classFile);
UInt32 classId = XmlUtil.GetAttributeUInt(doc.DocumentElement, XmlTags.XMLATT_ClassID);
ClassPointer appClassPointer = _project.GetTypedData <ClassPointer>(classId);
if (appClassPointer == null)
{
loadedHere = true;
appClassPointer = ClassPointer.CreateClassPointer(_project, doc.DocumentElement);
}
if (appClassPointer.ObjectList.Count == 0)
{
appClassPointer.ObjectList.LoadObjects();
}
_appCodeName = appClassPointer.CodeName;
LimnorWebApp webapp = appClassPointer.ObjectInstance as LimnorWebApp;
if (webapp != null)
{
_sessionVarCount = webapp.GlobalVariables.Count;
if (webapp.GlobalVariables.Count > 0)
{
Dictionary <string, string> sessionVars = new Dictionary <string, string>();
foreach (SessionVariable sv in webapp.GlobalVariables)
{
if (!sessionVars.ContainsKey(sv.Name))
{
if (!sv.Value.IsDefaultValue())
{
sessionVars.Add(sv.Name, sv.Value.GetValueString());
}
}
}
_sessionVarNames = new string[sessionVars.Count];
_sessionVarValues = new string[sessionVars.Count];
int idx = 0;
foreach (KeyValuePair <string, string> kv in sessionVars)
{
_sessionVarNames[idx] = kv.Key;
_sessionVarValues[idx] = kv.Value;
idx++;
}
}
_sessionTimeoutMinutes = webapp.GlobalVariableTimeout;
if (_sessionTimeoutMinutes <= 0)
{
_sessionTimeoutMinutes = 20;
}
}
if (loadedHere)
{
_project.RemoveTypedData <ClassPointer>(classId);
}
}
public IClassPointer GetClassPointerFromCache(LimnorProject proj, UInt32 classId)
{
ClassPointer cp = proj.GetTypedData <ClassPointer>(classId);
if (cp == null)
{
cp = ClassPointer.CreateClassPointer(classId, proj);
}
return(cp);
}
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 string ToString()
{
if (_classId != 0 && _prj != null)
{
ClassPointer cp = ClassPointer.CreateClassPointer(_classId, _prj);
if (cp != null)
{
return(cp.Name);
}
}
return(string.Empty);
}
protected virtual void OnCreateFirstFormDebug()
{
ClassPointer startForm = null;
if (_startClassId != 0)
{
startForm = ClassPointer.CreateClassPointer(_startClassId, Project);
}
if (startForm != null)
{
CodeExpressionStatement cs = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Application)), "Run",
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(startForm.TypeString), DrawingPage.DEFAULTFORM)));
mainMethod.Statements.Add(cs);
}
else if (_startForm != null)
{
string formName = DesignUtil.CreateUniqueName("form");
mainMethod.Statements.Add(new CodeVariableDeclarationStatement(
_startForm.GetTypeName(this.Namespace), formName, new CodeObjectCreateExpression(_startForm.GetTypeName(this.Namespace))
));
//
mainMethod.Statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
DebuggerVar, "OnCreateComponent",
new CodePrimitiveExpression(_startForm.ObjectKey),
new CodeVariableReferenceExpression(formName)
)
)
);
//
if (!InitializeComponentAdded())
{
CodeMethodReferenceExpression mre = new CodeMethodReferenceExpression();
mre.MethodName = "InitializeComponent";
mainMethod.Statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(mre, new CodeExpression[] { })
));
}
//
CodeExpressionStatement cs = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Application)), "Run",
new CodeVariableReferenceExpression(formName)));
mainMethod.Statements.Add(cs);
}
else
{
throw new DesignerException("StartForm property is not specified in the application class.");
}
}
public static Type CreateClassType(UInt32 classId, Guid projectGuid)
{
Type t = VPLUtil.GetClassType(classId, projectGuid);
if (t == null)
{
ClassPointer root = null;
LimnorProject prj = LimnorSolution.GetLimnorProjectByGuid(projectGuid);
if (prj != null)
{
root = ClassPointer.CreateClassPointer(classId, prj);
}
string typename = null;
if (root != null)
{
typename = root.Name;
}
if (string.IsNullOrEmpty(typename))
{
typename = string.Format(CultureInfo.InvariantCulture,
"Class_{0}_{1}", classId, projectGuid.ToString("N", CultureInfo.InvariantCulture));
}
string name = string.Format(CultureInfo.InvariantCulture,
"{0}{1}", VPLUtil.ASSEMBLYNAME_PRE, classId.ToString("x", CultureInfo.InvariantCulture));
AssemblyName aName = new AssemblyName(name);
AssemblyBuilder ab =
AppDomain.CurrentDomain.DefineDynamicAssembly(
aName,
AssemblyBuilderAccess.RunAndSave);
// For a single-module assembly, the module name is usually
// the assembly name plus an extension.
ModuleBuilder mb =
ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");
TypeBuilder tb = mb.DefineType(
typename,
TypeAttributes.Public, typeof(ClassPointerX));
ConstructorInfo cif = typeof(ClassIdAttribute).GetConstructor(new Type[] { typeof(UInt32), typeof(string) });
CustomAttributeBuilder cab = new CustomAttributeBuilder(cif, new object[] { (UInt32)classId, projectGuid.ToString("N", CultureInfo.InvariantCulture) });
tb.SetCustomAttribute(cab);
t = tb.CreateType();
VPLUtil.SetClassType(classId, projectGuid, t);
}
return(t);
}
public static ClassPointer GetClassPointer(Type t)
{
object[] vs = t.GetCustomAttributes(typeof(ClassIdAttribute), true);
if (vs != null && vs.Length > 0)
{
ClassIdAttribute cia = vs[0] as ClassIdAttribute;
if (cia != null)
{
LimnorProject prj = LimnorSolution.GetLimnorProjectByGuid(cia.ProjectGuid);
if (prj != null)
{
ClassPointer c = ClassPointer.CreateClassPointer(cia.ClassID, prj);
return(c);
}
}
}
return(null);
}
protected override void OnLoad(System.Xml.XmlNode node)
{
_propertyId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_PropId);
XmlNode nd = SerializeUtil.GetCustomPropertyNode(node, (UInt32)_propertyId);
if (nd != null)
{
XmlSerializer.XmlObjectReader xr = this.root.Reader as XmlSerializer.XmlObjectReader;
if (xr != null)
{
_property = (PropertyClass)xr.ReadObject(nd, ClassPointer.CreateClassPointer(xr.ObjectList));
}
else
{
throw new DesignerException("Reader not available calling MathNodePropertyField.OnLoad");
}
}
}
protected virtual void OnCreateFirstForm()
{
ClassPointer startForm = null;
if (_startClassId != 0)
{
startForm = ClassPointer.CreateClassPointer(_startClassId, Project);
}
if (startForm != null)
{
if (!InitializeComponentAdded())
{
CodeMethodReferenceExpression mre = new CodeMethodReferenceExpression();
mre.MethodName = "InitializeComponent";
mainMethod.Statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(mre, new CodeExpression[] { })
));
}
CodeExpressionStatement cs = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Application)), "Run",
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(startForm.TypeString), DrawingPage.DEFAULTFORM)));
mainMethod.Statements.Add(cs);
}
else if (_startForm != null)
{
CodeMethodReferenceExpression mre = new CodeMethodReferenceExpression();
mre.MethodName = "InitializeComponent";
mainMethod.Statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(mre, new CodeExpression[] { })
));
//
CodeExpressionStatement cs = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Application)), "Run",
new CodeVariableReferenceExpression(StartPage.Name)));
//
mainMethod.Statements.Add(cs);
}
else
{
throw new DesignerException("StartForm property is not specified in the application class.");
}
}
/// <summary>
/// called from the holding class
/// </summary>
/// <param name="reader"></param>
/// <param name="node"></param>
public void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
_xmlNode = node;
//retrieve _holder, _method
//method id
UInt32 memberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_MethodID);
MemberId = memberId; //method id
//
UInt32 varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_varId);
if (varId == 0)
{
//try backward compatible
varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
if (varId != 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
LocalVariable lv = root0.GetLocalVariable(varId);
if (lv == null)
{
varId = 0;
}
else
{
_holder = lv;
ClassId = lv.ClassType.DefinitionClassId;
ClassPointer r = reader.ObjectList.Project.GetTypedData <ClassPointer>(ClassId);
_method = r.GetCustomMethodById(memberId);
}
}
}
if (varId != 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
LocalVariable lv = root0.GetLocalVariable(varId);
_holder = lv;
ClassId = lv.ClassType.DefinitionClassId;
ClassPointer r = reader.ObjectList.Project.GetTypedData <ClassPointer>(ClassId);
_method = r.GetCustomMethodById(memberId);
}
else
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
if (cp.Definition == null)
{
cp.ReplaceDeclaringClassPointer(ClassPointer.CreateClassPointer(cp.DefinitionClassId, reader.ObjectList.Project));
}
_method = cp.Definition.GetCustomMethodById(memberId);
_holder = cp;
ClassId = cp.DefinitionClassId;
}
else
{
UInt32 cid = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ownerClassID);
if (cid != 0)
{
ClassPointer root0 = ClassPointer.CreateClassPointer(cid, reader.ObjectList.Project);
varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_instanceId);
if (varId != 0)
{
ClassPointer root = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = new ClassInstancePointer(root, root0, varId);
ClassId = root.ClassId;
}
else
{
_holder = root0;
ClassId = root0.ClassId;
}
_method = root0.GetCustomMethodById(memberId);
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
ClassId = root0.ClassId;
_method = root0.GetCustomMethodById(memberId);
}
}
}
}
if (_method == null)
{
//===backward compatibility========================================
UInt32 classId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID);
ClassId = classId;
UInt32 instId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_instanceId);
if (instId != 0)
{
if (classId != 0 && classId != reader.ObjectList.ClassId)
{
//it is a static instance from another class
//for a custom class the holder is a MemberComponentIdCustom
//for a library class the holder is a
ClassPointer cp0 = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
if (cp0 == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Class {0} not found in the project", classId);
}
else
{
if (cp0.ObjectList.Count == 0)
{
//cp0 not loaded. load it now
cp0.ObjectList.LoadObjects();
if (cp0.ObjectList.Reader.HasErrors)
{
MathNode.Log(cp0.ObjectList.Reader.Errors);
cp0.ObjectList.Reader.ResetErrors();
}
}
IClassRef ic = cp0.ObjectList.GetClassRefById(instId);
if (ic == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Instance {0} not found in Class {1}", instId, classId);
}
else
{
ClassInstancePointer vi = ic as ClassInstancePointer;
if (vi == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Instance {0},{1} in Class {2} is not a class-instance-pointer", instId, ic.GetType(), classId);
}
else
{
MemberComponentIdCustom mc = new MemberComponentIdCustom(cp0, vi, instId);
_holder = mc;
_method = vi.Definition.GetCustomMethodById(memberId);
}
}
}
}
else
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
ClassInstancePointer vi = (ClassInstancePointer)cp.Definition.ObjectList.GetClassRefById(instId);
MemberComponentIdCustomInstance mcci = new MemberComponentIdCustomInstance(cp, vi, instId);
_holder = mcci;
_method = vi.Definition.GetCustomMethodById(memberId);
ClassId = vi.ClassId;
}
else
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
ClassInstancePointer cp = (ClassInstancePointer)reader.ObjectList.GetClassRefById(instId);
if (cp != null)
{
MemberComponentIdCustom mcc = new MemberComponentIdCustom(root0, cp, instId);
_holder = mcc;
_method = cp.Definition.GetCustomMethodById(memberId);
ClassId = cp.ClassId;
}
else
{
//try to fix the error
foreach (object o in reader.ObjectList.Keys)
{
cp = reader.ObjectList.GetClassRefByObject(o) as ClassInstancePointer;
if (cp != null)
{
_method = cp.Definition.GetCustomMethodById(memberId);
if (_method != null)
{
instId = reader.ObjectList.GetObjectID(o);
_holder = new MemberComponentIdCustom(root0, cp, instId);
ClassId = cp.ClassId;
//fix the instance id
XmlUtil.SetAttribute(node, XmlTags.XMLATT_instanceId, instId);
break;
}
}
}
if (_holder == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Component {0} is not a customer class instance in class {1}", instId, root0.ClassId);
}
}
}
}
}
else
{
if (classId == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
_method = root0.GetCustomMethodById(memberId);
}
else
{
ClassPointer root0 = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
if (root0 != null)
{
_holder = root0;
_method = root0.GetCustomMethodById(memberId);
}
if (_method == null)
{
//backward compatibility
UInt32 holderMemberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
ClassPointer root = reader.ObjectList.GetTypedData <ClassPointer>();
UInt32 holderClassId = XmlUtil.GetAttributeUInt(node.OwnerDocument.DocumentElement, XmlTags.XMLATT_ClassID);
if (holderClassId == classId) //holder is in the same class
{
_method = root.GetCustomMethodById(memberId);
if (holderMemberId == 0 || holderMemberId == reader.ObjectList.MemberId) //not an instance
{
_holder = root;
}
else
{
_holder = (IClass)reader.ObjectList.GetClassRefById(holderMemberId);
}
if (_holder == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid method holder Id [{0},{1}] for method [{2}.{3}]", classId, holderMemberId, _method.Owner, _method.Name);
}
}
else //holder and declarer are different classes
{
ClassPointer declarer = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
_method = declarer.GetCustomMethodById(memberId);
if (_method == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Method [{0}] not found in class [{1}]", memberId, classId);
}
else
{
//holder an instance?
object v = reader.ObjectList.GetObjectByID(holderMemberId);
if (v != null)
{
if (v == reader.ObjectList.GetRootObject())
{
_holder = reader.ObjectList.GetTypedData <ClassPointer>();
}
else
{
_holder = reader.ObjectList.GetClassRefByObject(v) as IClass;
}
}
if (_holder == null)
{
//holder is a local variable
LocalVariable lv = root.GetLocalVariable(holderMemberId);
_holder = lv;
}
if (_holder == null)
{
_error = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid method holder Id [{0},{1}] for method [{2}.{3}] from declaring class {4}", holderClassId, holderMemberId, _method.Owner, _method.Name, classId);
}
}
}
}
}
}
}
}
protected virtual void OnRead(IXmlCodeReader reader, XmlNode node)
{
//get local variable from method component list based on _memberId
XmlNode varNode = DesignUtil.GetMethodVariableNode(node.OwnerDocument.DocumentElement, _memberId);
if (varNode == null)
{
LocalVariable v = LocalVariable.GetUnsavedLocalVariable(_classId, _memberId);
if (v == null)
{
//it can be a variable in an exception handler
//get method id
UInt32 methodId = 0;
XmlNode mn = node;
while (mn != null)
{
methodId = XmlUtil.GetAttributeUInt(mn, XmlTags.XMLATT_ScopeId);
if (methodId != 0)
{
break;
}
mn = mn.ParentNode;
}
if (methodId != 0)
{
ClassPointer root = ((XmlObjectReader)reader).ObjectList.GetTypedData <ClassPointer>();
MethodClass mc = root.GetCustomMethodById(methodId);
if (mc != null)
{
v = mc.GetLocalVariable(_memberId);
}
}
else
{
DesignUtil.WriteToOutputWindowAndLog("Error reading local variable. Variable node not found [{0},{1}]", _classId, _memberId);
}
}
if (v != null)
{
_name = v.Name;
_type = v.ClassType;
_owner = v._owner;
_instance = v._instance;
_nameChecker = v._nameChecker;
_debug = v._debug;
}
}
else
{
_name = XmlUtil.GetNameAttribute(varNode);
Type t = XmlUtil.GetLibTypeAttribute(varNode);
if (t != null)
{
if (t.Equals(typeof(ParameterClass)))
{
MethodClass mc = _owner as MethodClass;
if (mc != null)
{
_type = (DataTypePointer)Activator.CreateInstance(t, mc);
}
}
else
{
_type = (DataTypePointer)Activator.CreateInstance(t);
}
reader.ReadObjectFromXmlNode(varNode, _type, t, this);
}
else
{
UInt32 id = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
if (id != 0)
{
//try to get it from exception handler of a method
ClassPointer root = ClassPointer.CreateClassPointer(((XmlObjectReader)reader).ObjectList);
LocalVariable v = root.GetLocalVariable(id);
if (v != null)
{
_name = v.Name;
_type = v.ClassType;
_owner = v._owner;
_instance = v._instance;
_nameChecker = v._nameChecker;
_debug = v._debug;
}
}
else
{
#if DEBUG
throw new DesignerException("Error reading local variable from class [{0}]. XPath:[{1}]", reader.ClassId, XmlUtil.GetPath(node));
#endif
}
}
}
}
/// <summary>
/// called from the holding class
/// </summary>
/// <param name="reader"></param>
/// <param name="node"></param>
public void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
//retrieve _holder, _event
UInt32 memberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_EventId); //declaring event id
MemberId = memberId;
//
UInt32 varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_varId);
if (varId != 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
LocalVariable lv = root0.GetLocalVariable(varId);
_holder = lv;
ClassId = lv.ClassType.DefinitionClassId;
ClassPointer r = reader.ObjectList.Project.GetTypedData <ClassPointer>(ClassId);
_event = r.GetCustomEventById(memberId);
}
else
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
_event = cp.Definition.GetCustomEventById(memberId);
_holder = cp;
ClassId = cp.DefinitionClassId;
}
else
{
UInt32 cid = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ownerClassID);
if (cid != 0)
{
ClassPointer root0 = ClassPointer.CreateClassPointer(cid, reader.ObjectList.Project);
_holder = root0;
ClassId = root0.ClassId;
_event = root0.GetCustomEventById(memberId);
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
ClassId = root0.ClassId;
_event = root0.GetCustomEventById(memberId);
}
}
}
}
if (_event == null)
{
//===backward compatibility==================================================
UInt32 instId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_instanceId);
if (instId != 0)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
ClassInstancePointer vi = (ClassInstancePointer)cp.Definition.ObjectList.GetClassRefById(instId);
MemberComponentIdCustomInstance mcci = new MemberComponentIdCustomInstance(cp, vi, instId);
_holder = mcci;
_event = vi.Definition.GetCustomEventById(memberId);
ClassId = vi.ClassId;
}
else
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
ClassInstancePointer cp = (ClassInstancePointer)reader.ObjectList.GetClassRefById(instId);
MemberComponentIdCustom mcc = new MemberComponentIdCustom(root0, cp, instId);
_holder = mcc;
_event = cp.Definition.GetCustomEventById(memberId);
ClassId = cp.ClassId;
}
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
ClassId = root0.ClassId;
_holder = root0;
_event = root0.GetCustomEventById(memberId);
}
else
{
//backward compatibility
UInt32 classId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID); //declaring class id
UInt32 holderMemberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID); //holding class member id
ClassId = classId;
MemberId = memberId;
UInt32 holderClassId = XmlUtil.GetAttributeUInt(node.OwnerDocument.DocumentElement, XmlTags.XMLATT_ClassID);
ClassPointer root = reader.ObjectList.Project.GetTypedData <ClassPointer>(holderClassId);
if (holderClassId == classId) //holder is in the same class
{
_event = root.GetCustomEventById(memberId);
if (holderMemberId == 0 || holderMemberId == reader.ObjectList.MemberId) //not an instance
{
_holder = ClassPointer.CreateClassPointer(reader.ObjectList);
}
else
{
_holder = (IClass)reader.ObjectList.GetClassRefById(holderMemberId);
}
}
else //holder and declarer are different classes
{
ClassPointer baseClass = root.GetBaseClass(classId);
if (baseClass != null)
{
EventClass eb = baseClass.GetCustomEventById(memberId);
if (eb == null)
{
throw new DesignerException("Error reading custom event pointer: invalid event Id [{0},{1}] in class [{2}]", classId, memberId, holderClassId);
}
_event = eb.CreateInherited(root);
}
else
{
ClassPointer declarer = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
_event = declarer.GetCustomEventById(memberId);
}
//holder an instance?
object v = reader.ObjectList.GetObjectByID(holderMemberId);
if (v != null)
{
_holder = reader.ObjectList.GetClassRefByObject(v) as IClass;
}
if (_holder == null)
{
//holder is a local variable
//ClassPointer root = reader.ObjectList.GetTypedData<ClassPointer>();
LocalVariable lv = root.GetLocalVariable(holderMemberId);
_holder = lv;
}
}
}
}
}
if (_event == null)
{
throw new DesignerException("Error reading custom event pointer: [{0}]", node.InnerXml);
}
if (_holder == null)
{
throw new DesignerException("Invalid custom event pointer. Holder not found. [{0}]", node.InnerXml);
}
}
public void OnPostSerialize(ObjectIDmap objMap, XmlNode objectNode, bool saved, object serializer)
{
if (saved)
{
XmlUtil.SetNameAttribute(objectNode, _name);
XmlUtil.SetAttribute(objectNode, XmlTags.XMLATT_instanceId, _memberId);
XmlUtil.SetAttribute(objectNode, XmlTags.XMLATT_ClassID, ClassId);
ClassInstancePointer ip = _hostingClass as ClassInstancePointer;
if (ip != null)
{
XmlNode nd = XmlUtil.CreateSingleNewElement(objectNode, XmlTags.XML_ClassInstance);
ip.OnPostSerialize(objMap, nd, saved, serializer);
}
else
{
ClassPointer root = _hostingClass as ClassPointer;
if (root != null)
{
if (root.ClassId != objMap.ClassId)
{
XmlUtil.SetAttribute(objectNode, XmlTags.XMLATT_hostClassId, root.ClassId);
}
}
}
//save custom property values
if (_properties != null)
{
XmlObjectWriter writer = (XmlObjectWriter)serializer;
PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(_properties.ToArray());
writer.WriteProperties(objectNode, pdc, this, XmlTags.XML_PROPERTY);
}
}
else
{
_name = XmlUtil.GetNameAttribute(objectNode);
if (_memberId == 0)
{
_memberId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_instanceId);
}
XmlNode nd = objectNode.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd == null)
{
//load _hostingClass
if (_hostingClass == null)
{
ClassPointer root;
UInt32 hostClassId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_hostClassId);
if (hostClassId == 0)
{
root = ClassPointer.CreateClassPointer(objMap);
}
else
{
if (hostClassId == objMap.ClassId)
{
root = ClassPointer.CreateClassPointer(objMap);
}
else
{
root = ClassPointer.CreateClassPointer(hostClassId, objMap.Project);
}
}
if (root == null)
{
throw new DesignerException("Invalid class id: {0}", hostClassId);
}
_hostingClass = root;
if (_definingClassId == 0) //ClassId may be loaded by property deserialize
{
IClassRef r = root.ObjectList.GetClassRefById(MemberId);
if (r != null)
{
_definingClassId = r.ClassId;
}
}
}
//load _definingClass
if (_definingClass == null)
{
if (_definingClassId == 0)
{
_definingClassId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_ClassID);
}
if (_definingClassId == 0)
{
ClassPointer root = (ClassPointer)_hostingClass;
IClassRef r = root.ObjectList.GetClassRefById(MemberId);
if (r != null)
{
_definingClassId = r.ClassId;
}
}
_definingClass = ClassPointer.CreateClassPointer(_definingClassId, objMap.Project);
}
}
else
{
_definingClassId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_ClassID);
ClassInstancePointer ip = new ClassInstancePointer();
ip.OnPostSerialize(objMap, nd, saved, serializer);
_hostingClass = ip;
if (this.ClassId == 0) //ClassId may be loaded by property deserialize
{
if (_hostingClass.Definition.ObjectList.Count == 0)
{
_hostingClass.Definition.ObjectList.LoadObjects();
if (_hostingClass.Definition.ObjectList.Reader.HasErrors)
{
MathNode.Log(_hostingClass.Definition.ObjectList.Reader.Errors);
_hostingClass.Definition.ObjectList.Reader.ResetErrors();
}
}
IClassRef r = _hostingClass.Definition.ObjectList.GetClassRefById(_memberId);
_definingClassId = r.ClassId;
}
if (_definingClass == null)
{
_definingClass = ClassPointer.CreateClassPointer(_definingClassId, objMap.Project);
}
}
if (MemberId == 0 && _definingClassId == 0)
{
//backward compatebility
_definingClassId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_ClassID);
MemberId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_ComponentID);
_definingClass = objMap.Project.GetTypedData <ClassPointer>(_definingClassId);
_hostingClass = objMap.GetTypedData <ClassPointer>();
}
if (_definingClass != null) //not being deleted
{
//load custom property definitions
XmlObjectReader reader = _definingClass.ObjectList.Reader;
if (reader == null)
{
reader = (XmlObjectReader)serializer;
}
LoadProperties(reader);
//load custom property values
LoadCustomPropertyValues(reader, objectNode);
}
if (MemberId == 0)
{
MemberId = XmlUtil.GetAttributeUInt(objectNode, XmlTags.XMLATT_ComponentID);
}
}
}
public TypeX(UInt32 classId, LimnorProject project)
{
_classId = classId;
_classPointer = ClassPointer.CreateClassPointer(classId, project);
}
/// <summary>
/// called from the holding class
/// </summary>
/// <param name="reader"></param>
/// <param name="node"></param>
public virtual void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
//retrieve _holder, _property
UInt32 memberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_PropId); //declaring property id
MemberId = memberId; //id PropertyClass
//
UInt32 varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_varId);
if (varId != 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
if (root0 == null)
{
root0 = reader.ObjectList.Project.GetTypedData <ClassPointer>(reader.ObjectList.ClassId);
if (root0 == null)
{
root0 = reader.ObjectList.RootPointer as ClassPointer;
if (root0 == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Class Id = {0}. More info:{1}", reader.ObjectList.ClassId, getDebugInfo(reader0, node)));
}
}
}
if (root0 != null)
{
LocalVariable lv = root0.GetLocalVariable(varId);
_holder = lv;
if (lv.ClassType == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Local variable [{0}]'s data type is null. More info:{1}", lv, getDebugInfo(reader0, node)));
}
else
{
ClassId = lv.ClassType.DefinitionClassId;
ClassPointer r = reader.ObjectList.Project.GetTypedData <ClassPointer>(ClassId);
if (r == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Class ID [{0}] of a local variable [{1}] does not point to a class. More info:{2}", ClassId, lv, getDebugInfo(reader0, node)));
}
else
{
_property = r.GetCustomPropertyById(memberId);
}
}
}
}
else
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
if (cp.Definition == null && cp.DefinitionClassId == 0)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer: Definition ID is 0. More info:{0}", getDebugInfo(reader0, node)));
}
else
{
if (cp.Definition == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer: Definition class not found. Definition class ID = {0}. If the class was removed from the project then the places using the class should be modified. More info:{1}", cp.DefinitionClassId, getDebugInfo(reader0, node)));
}
else
{
_property = cp.Definition.GetCustomPropertyById(memberId);
}
_holder = cp;
ClassId = cp.DefinitionClassId;
}
}
else
{
UInt32 cid = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ownerClassID);
if (cid != 0)
{
ClassPointer root0 = ClassPointer.CreateClassPointer(cid, reader.ObjectList.Project);
_holder = root0;
if (root0 == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Owner class ID [{0}] does not point to a class. More info:{1}", cid, getDebugInfo(reader0, node)));
}
else
{
ClassId = root0.ClassId;
_property = root0.GetCustomPropertyById(memberId);
}
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
if (root0 == null)
{
root0 = reader.ObjectList.Project.GetTypedData <ClassPointer>(reader.ObjectList.ClassId);
if (root0 == null)
{
root0 = reader.ObjectList.RootPointer as ClassPointer;
if (root0 == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Current class ID [{0}] does not point to a class. More info:{1}", reader.ObjectList.ClassId, getDebugInfo(reader0, node)));
}
}
}
if (root0 != null)
{
ClassId = root0.ClassId;
_property = root0.GetCustomPropertyById(memberId);
}
}
}
}
}
if (_holder == null)
{
//==backward compatibility===========================================================
UInt32 classId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID); //declaring class id
UInt32 holderMemberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID);
ClassId = classId; //definition class
//root holding class
ClassPointer root = reader.ObjectList.GetTypedData <ClassPointer>();
if (root == null)
{
root = reader.ObjectList.Project.GetTypedData <ClassPointer>(reader.ObjectList.ClassId);
if (root == null)
{
root = reader.ObjectList.RootPointer as ClassPointer;
if (root == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer. Holding class, class ID [{0}], does not point to a class. More info:{1}", reader.ObjectList.ClassId, getDebugInfo(reader0, node)));
}
}
}
//
UInt32 holderClassId = XmlUtil.GetAttributeUInt(node.OwnerDocument.DocumentElement, XmlTags.XMLATT_ClassID);
if (holderClassId == classId) //holder is in the same class
{
//
if (root != null)
{
_property = root.GetCustomPropertyById(MemberId);
if (_property != null && _property.IsStatic)
{
_holder = root;
}
}
}
else //holder and declarer are different classes
{
//root is the holding class
ClassPointer declarer = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
if (declarer == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Error reading CustomPropertyPointer: classId {0} does not point to a class. If the class was removed from the class then please modify places using the class. More info:{1}", classId, getDebugInfo(reader0, node)));
}
else
{
_property = declarer.GetCustomPropertyById(memberId);
if (_property != null && _property.IsStatic)
{
_holder = declarer;
}
}
}
if (_property != null && !_property.IsStatic)
{
if (holderMemberId == 0 || holderMemberId == reader.ObjectList.MemberId) //not an instance
{
_holder = root;
}
else
{
_holder = (IClass)reader.ObjectList.GetClassRefById(holderMemberId);
}
if (_holder == null)
{
//holder is a local variable
LocalVariable lv = root.GetLocalVariable(holderMemberId);
_holder = lv;
}
_property.SetHolder(_holder);
}
}
if (_holder == null)
{
MathNode.Log(TraceLogClass.MainForm, new DesignerException("Invalid property pointer [{0}]. More info:{1}", node.InnerXml, getDebugInfo(reader0, node)));
}
}
public IClassPointer CreateClassPointer(ObjectIDmap map)
{
ClassPointer cp = ClassPointer.CreateClassPointer(map);
return(cp);
}