public override TreeNodeObject LocateObjectNode(Stack <IObjectPointer> ownerStack)
{
if (ownerStack.Count > 0)
{
IObjectPointer o = ownerStack.Pop();
MethodParamPointer mpp = o as MethodParamPointer;
if (mpp == null)
{
throw new DesignerException("TreeNodeConstructor.LocateObjectNode:{0} is not a MethodParamPointer", o.GetType());
}
for (int i = 0; i < this.Nodes.Count; i++)
{
TreeNodeMethodParameter tmp = Nodes[i] as TreeNodeMethodParameter;
if (tmp != null)
{
if (tmp.OwnerPointer.IsSameObjectRef(mpp))
{
if (ownerStack.Count == 0)
{
return(tmp);
}
else
{
return(tmp.LocateObjectNode(ownerStack));
}
}
}
}
}
return(null);
}
public void OnComponentRemoved(object obj)
{
ObjectIDmap map = null;
ClassInstancePointer cr = obj as ClassInstancePointer;
if (cr != null)
{
map = _loader.ObjectMap.GetMap(cr.ObjectInstance);
}
else
{
map = _loader.ObjectMap.GetMap(obj);
}
if (map != null)
{
TreeNode node = null;
if (cr != null)
{
node = _objExplorer.LocateNode(cr);
}
else
{
IObjectPointer o = DesignUtil.CreateObjectPointer(map, obj);
node = _objExplorer.LocateNode(o);
}
if (node != null)
{
node.Remove();
}
}
}
public static bool IsOwnedByControl(IObjectPointer owner)
{
if (owner != null)
{
Type tc = typeof(Control);
if (owner.Owner == null)
{
return(tc.IsAssignableFrom(owner.ObjectType));
}
Type tc2 = typeof(ToolStripItem);
IObjectPointer o = owner;
while (o != null && o.Owner != null)
{
if (tc.IsAssignableFrom(o.ObjectType))
{
return(true);
}
if (tc2.IsAssignableFrom(o.ObjectType))
{
return(true);
}
o = o.Owner;
}
}
return(false);
}
public DataTypePointer GetConcreteType(Type typeParameter)
{
if (ClassType != null)
{
DataTypePointer dp = _type.GetConcreteType(typeParameter);
if (dp != null)
{
return(dp);
}
}
IGenericTypePointer igp = null;
IObjectPointer op = Owner;
while (op != null)
{
igp = op as IGenericTypePointer;
if (igp != null)
{
break;
}
op = op.Owner;
}
if (igp != null)
{
return(igp.GetConcreteType(typeParameter));
}
return(null);
}
public override void OnDoubleClick(Control host)
{
Form f = host.FindForm();
host.Cursor = System.Windows.Forms.Cursors.WaitCursor;
if (f != null)
{
f.Cursor = System.Windows.Forms.Cursors.WaitCursor;
}
IObjectPointer pp = _valuePointer;
IMethod method = null;
MathNodeRoot r = this.root;
if (r != null)
{
method = r.ScopeMethod;
}
FrmObjectExplorer dlg = DesignUtil.GetPropertySelector(pp, method, null);
if (dlg != null)
{
if (dlg.ShowDialog(f) == DialogResult.OK)
{
_valuePointer = dlg.SelectedObject as IObjectPointer;
host.Invalidate();
}
}
host.Cursor = System.Windows.Forms.Cursors.Default;
if (f != null)
{
f.Cursor = System.Windows.Forms.Cursors.Default;
}
}
public void OnComponentRemoved(object obj)
{
ObjectIDmap map = null;
ClassInstancePointer cr = obj as ClassInstancePointer;
if (cr != null)
{
map = _loader.ObjectMap.GetMap(cr.ObjectInstance);
}
else
{
map = _loader.ObjectMap.GetMap(obj);
}
//if (map == null)
//{
// throw new DesignerException("object map not found for {0} when removing component", obj);
//}
if (map != null)
{
TreeNode node = null;
if (cr != null)
{
node = _objExplorer.LocateNode(cr);
}
else
{
IObjectPointer o = DesignUtil.CreateObjectPointer(map, obj);
node = _objExplorer.LocateNode(o);
}
if (node != null)
{
node.Remove();
}
}
}
/// <summary>
/// It can be a ClassPointer, a MemberComponentId, or a TypePointer.
///
/// </summary>
/// <returns></returns>
private IClass getActionExecuter()
{
IPropertySetter sp = ActionMethod as IPropertySetter;
if (sp != null)
{
MemberComponentIdCustom c = sp.SetProperty.Holder as MemberComponentIdCustom;
if (c != null)
{
return(c.Pointer);
}
return(sp.SetProperty.Holder);
}
else
{
IObjectIdentity mp = ActionMethod.IdentityOwner;
IMemberPointer p = ActionMethod as IMemberPointer;
if (p != null)
{
return(p.Holder);
}
MemberComponentIdCustom mcc = mp as MemberComponentIdCustom;
if (mcc != null)
{
return(mcc.Pointer);
}
MemberComponentId mmc = mp as MemberComponentId;
if (mmc != null)
{
return(mmc);
}
p = mp as IMemberPointer;
if (p != null)
{
return(p.Holder);
}
IObjectPointer op = mp as IObjectPointer;
IClass co = mp as IClass;
while (co == null && op != null)
{
op = op.Owner;
co = op as IClass;
p = op as IMemberPointer;
if (p != null)
{
return(p.Holder);
}
}
if (co != null)
{
return(co);
}
else
{
throw new DesignerException("Cannot find holder for Action [{0}]", ActionId);
}
}
}
public void ReadFromXmlNode(XmlObjectReader reader, XmlNode node)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_Property);
if (nd != null)
{
_valuePointer = (IObjectPointer)reader.ReadObject(nd, null);
}
}
public void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_PROPERTY);
if (nd != null)
{
_valuePointer = (IObjectPointer)reader.ReadObject(nd, null);
}
}
public override bool IsForThePointer(IObjectPointer pointer)
{
DataTypePointer cp = pointer as DataTypePointer;
if (cp != null && cp.BaseClassType != null)
{
return(cp.BaseClassType.Equals(this.ClassType));
}
return(false);
}
public override bool IsForThePointer(IObjectPointer pointer)
{
MethodClass ic = pointer as MethodClass;
if (ic != null)
{
return(ic.MethodID == this.MethodId);
}
return(false);
}
public override bool IsForThePointer(IObjectPointer pointer)
{
PropertyClass ic = pointer as PropertyClass;
if (ic != null)
{
return(ic.MemberId == this.PropertyId);
}
return(false);
}
public override bool IsForThePointer(IObjectPointer pointer)
{
ClassPointer cp = pointer as ClassPointer;
if (cp != null)
{
return(cp.ClassId == this.ClassId);
}
return(false);
}
public virtual bool IsForThePointer(IObjectPointer pointer)
{
IClass ic = pointer as IClass;
if (ic != null)
{
return(ic.ClassId == this.ClassId && ic.MemberId == this.MemberId);
}
return(false);
}
public void SetValueOwner(object o)
{
if (Owner == null)
{
IObjectPointer p = o as IObjectPointer;
if (p != null)
{
Owner = p;
}
}
}
public override void Execute(List <ParameterClass> eventParameters)
{
CompileResult cr = null;
int i = 0;
while (true)
{
if (RepeatCount.ValueType == EnumValueType.ConstantValue)
{
if (i < (int)RepeatCount.ConstantValue.GetValue(ConstObjectPointer.VALUE_Value))
{
break;
}
}
else if (RepeatCount.ValueType == EnumValueType.MathExpression)
{
MathNodeRoot r = RepeatCount.MathExpression as MathNodeRoot;
if (r == null)
{
break;
}
else
{
cr = r.DebugCompileUnit;
cr.Execute();
if (!Convert.ToBoolean(cr.ReturnValue))
{
break;
}
}
}
else
{
IObjectPointer p = RepeatCount.Property;
if (p == null)
{
break;
}
if (p.ObjectInstance == null)
{
break;
}
if (i < (int)(p.ObjectInstance))
{
break;
}
}
ExecuteActions(eventParameters);
i++;
}
}
public void OnPostSerialize(XmlSerializer.ObjectIDmap objMap, System.Xml.XmlNode objectNode, bool saved, object serializer)
{
if (saved)
{
}
else
{
_root = objMap.RootPointer as ClassPointer;
if (_owner == null)
{
_owner = objMap.RootPointer as IObjectPointer;
}
}
}
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);
}
}
}
/// <summary>
/// find the tree node for the object to adjust text
/// </summary>
/// <param name="obj"></param>
/// <param name="newName"></param>
public void OnComponentRename(object obj, string newName)
{
ObjectIDmap map = _loader.ObjectMap.GetMap(obj);
if (map == null)
{
throw new DesignerException("object map not found for {0} when setting new name {1}", obj, newName);
}
IObjectPointer o = DesignUtil.CreateObjectPointer(map, obj);
TreeNodeObject node = _objExplorer.LocateNode(o) as TreeNodeObject;
if (node != null)
{
node.ShowText();
}
}
public void SetValueOwner(object o)
{
IObjectPointer p = o as IObjectPointer;
if (p != null)
{
if (_valuePointer == null)
{
}
else
{
if (_valuePointer.Owner == null)
{
}
}
}
}
public bool IsSameProperty(ISourceValuePointer p)
{
if (_valuePointer != null)
{
IObjectPointer vp = p as IObjectPointer;
if (vp != null)
{
return(_valuePointer.IsSameObjectRef(vp));
}
MathNodePointer mp = p as MathNodePointer;
if (mp != null)
{
return(_valuePointer.IsSameObjectRef(mp._valuePointer));
}
}
return(false);
}
public void OnComponentRemoved(object obj)
{
ObjectIDmap map = null;
ClassInstancePointer cr = obj as ClassInstancePointer;
if (cr != null)
{
map = _loader.ObjectMap.GetMap(cr.ObjectInstance);
}
else
{
map = _loader.ObjectMap.GetMap(obj);
if (map == null)
{
IComponent ic = obj as IComponent;
if (ic != null && ic.Site != null)
{
object key = _loader.ObjectMap.GetObjectByName(ic.Site.Name);
if (key != null)
{
obj = key;
map = _loader.ObjectMap;
}
}
}
}
if (map != null)
{
TreeNode node = null;
if (cr != null)
{
node = _objExplorer.LocateNode(cr);
}
else
{
IObjectPointer o = DesignUtil.CreateObjectPointer(map, obj);
node = _objExplorer.LocateNode(o);
}
if (node != null)
{
node.Remove();
}
}
}
public void SetValueOwner(object o)
{
ISourceValuePointer sv = _methodPointer as ISourceValuePointer;
if (sv != null)
{
sv.SetValueOwner(o);
}
if (_methodPointer != null)
{
if (_methodPointer.Owner == null)
{
IObjectPointer p = o as IObjectPointer;
if (p != null)
{
}
}
}
}
/// <summary>
/// EventPath only support the first level custom class instance
/// </summary>
/// <param name="pointer"></param>
/// <returns></returns>
public static IClass GetEventFirerRef(IObjectPointer pointer)
{
IClass ic = pointer as IClass;
while (pointer != null)
{
if (ic != null)
{
if (ic.Owner == null || (ic.Owner is ClassPointer))
{
return(ic);
}
}
pointer = pointer.Owner;
ic = pointer as IClass;
}
return(ic);
}
/// <summary>
/// find the tree node for the object to adjust text
/// </summary>
/// <param name="obj"></param>
/// <param name="newName"></param>
public void OnComponentRename(object obj, string newName)
{
HtmlElement_ItemBase hei = obj as HtmlElement_ItemBase;
if (hei != null)
{
_objExplorer.OnHtmlElementIdChanged(hei);
}
else
{
ObjectIDmap map = _loader.ObjectMap.GetMap(obj);
if (map == null)
{
map = _loader.ObjectMap;
}
IObjectPointer o = DesignUtil.CreateObjectPointer(map, obj);
TreeNodeObject node = _objExplorer.LocateNode(o) as TreeNodeObject;
if (node != null)
{
node.ShowText();
}
}
}
/// <summary>
/// generate code:
/// if( {event name} != null)
/// {
/// {event name}(parameters);
/// }
/// </summary>
/// <param name="compiler"></param>
/// <param name="methodToCompile"></param>
/// <param name="method"></param>
/// <param name="statements"></param>
/// <param name="debug"></param>
public void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
CodeConditionStatement cs = new CodeConditionStatement();
cs.Condition = new CodeBinaryOperatorExpression(
_event.GetReferenceCode(methodToCompile, statements, true), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeMethodInvokeExpression cme = new CodeMethodInvokeExpression();
if (_event.IsStatic || (_event.Declarer != null && _event.Declarer.IsStatic))
{
if (parameters != null && parameters.Count > 0)
{
CodeTypeReferenceExpression sender = parameters[0] as CodeTypeReferenceExpression;
if (sender != null)
{
if (string.CompareOrdinal(sender.Type.BaseType, _event.Owner.TypeString) == 0)
{
parameters[0] = new CodeTypeOfExpression(sender.Type.BaseType);
}
}
}
cme.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(_event.Owner.TypeString), _event.Name);
}
else
{
cme.Method = new CodeMethodReferenceExpression(_event.Owner.GetReferenceCode(methodToCompile, statements, false), _event.Name);
}
if (parameters != null)
{
cme.Parameters.AddRange(parameters);
}
cs.TrueStatements.Add(cme);
statements.Add(cs);
}
public void Compile(LimnorDesigner.Action.ActionBranch currentAction, LimnorDesigner.Action.ActionBranch nextAction, ILimnorCodeCompiler compiler, MathExp.IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, System.CodeDom.CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
throw new NotImplementedException();
}
public virtual void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
if (_method == null)
{
return;
}
CodeExpression cmi = null;
if (_method != null)
{
_method.SetHolder(_holder);
CodeMethodReferenceExpression mref = (CodeMethodReferenceExpression)_method.GetReferenceCode(methodToCompile, statements, false);
CodeMethodInvokeExpression cmim = new CodeMethodInvokeExpression();
cmim.Method = mref;
cmim.Parameters.AddRange(parameters);
cmi = cmim;
}
bool useOutput = false;
if (!NoReturn && nextAction != null && nextAction.UseInput)
{
CodeVariableDeclarationStatement output = new CodeVariableDeclarationStatement(
currentAction.OutputType.TypeString, currentAction.OutputCodeName, cmi);
statements.Add(output);
cmi = new CodeVariableReferenceExpression(currentAction.OutputCodeName);
useOutput = true;
}
if (HasReturn && returnReceiver != null)
{
CodeExpression cr = returnReceiver.GetReferenceCode(methodToCompile, statements, true);
if (_method.ReturnValue != null)
{
Type target;
IClassWrapper wrapper = returnReceiver as IClassWrapper;
if (wrapper != null)
{
target = wrapper.WrappedType;
}
else
{
target = returnReceiver.ObjectType;
}
Type dt;
if (useOutput)
{
dt = currentAction.OutputType.BaseClassType;
}
else
{
dt = _method.ReturnValue.BaseClassType;
}
CompilerUtil.CreateAssignment(cr, target, cmi, dt, statements, true);
}
else
{
CodeAssignStatement cas = new CodeAssignStatement(cr, cmi);
statements.Add(cas);
}
}
else
{
if (!useOutput)
{
CodeExpressionStatement ces = new CodeExpressionStatement(cmi);
statements.Add(ces);
}
}
}
public CodeExpression GetReferenceCode(IMethodCompile method, CodeStatementCollection statements, bool forValue)
{
CodeExpression ret = null;
if (_itemType != null)
{
//method.MethodCode.Statements
if (_array == null)
{
//without initializers
ret = _itemType.CreateArrayCreationCode();
}
else
{
//with initializers
if (_itemType.Rank == 1)
{
CodeExpression[] inits = new CodeExpression[_itemType.Dimnesions[0]];
for (int i = 0; i < inits.Length; i++)
{
object v = _array.GetValue(i);
if (v == null)
{
inits[i] = CompilerUtil.GetDefaultValueExpression(_itemType.ItemBaseType);
}
else
{
IObjectPointer op = v as IObjectPointer;
if (op != null)
{
inits[i] = op.GetReferenceCode(method, statements, forValue);
}
else
{
inits[i] = ObjectCreationCodeGen.ObjectCreationCode(v);
}
}
}
CodeArrayCreateExpression ac = new CodeArrayCreateExpression(_itemType.ItemBaseTypeString, inits);
ret = ac;
}
else
{
//only support constant element values
StringBuilder sb = new StringBuilder(CompilerUtil.CreateArrayCreationCodeString(_itemType.Rank, _itemType.ItemBaseTypeName));
sb.Append("{");
for (int i = 0; i < _itemType.Rank; i++)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("{");
for (int j = 0; j < _itemType.Dimnesions[i]; j++)
{
if (j > 0)
{
sb.Append(",");
}
sb.Append(ObjectCreationCodeGen.GetObjectCreationCodeSnippet(_array.GetValue(i, j)));
}
sb.Append("}");
}
sb.Append("}");
ret = new CodeSnippetExpression(sb.ToString());
//throw new NotImplementedException("Multi-dimensional array code not implemented");
}
}
}
return(ret);
}
public TypePointer(Type t, IObjectPointer owner)
: this(t)
{
_owner = owner;
}
