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; }