public ParameterValue CreateDefaultParameterValue(int idx) { IParameter p = null; if (_method != null && _method.Parameters != null) { if (idx >= 0 && idx < _method.Parameters.Count) { p = _method.Parameters[idx]; } } if (p != null) { ParameterValue pv = new ParameterValue(this.Action); pv.Name = p.Name; pv.ParameterID = p.ParameterID; ParameterClass pc = p as ParameterClass; if (pc != null) { pv.SetDataType(pc); } else { pv.SetDataType(p.ParameterLibType); } pv.SetOwnerAction(_act); pv.ValueType = EnumValueType.ConstantValue; return(pv); } return(null); }
private void onInstanceTypeChanged(object sender, EventArgs e) { if (_valType.ValueType == EnumValueType.ConstantValue) { _val.SetDataType((DataTypePointer)(_valType.ConstantValue.Value)); } }
private void adjustParamType() { if (_var != null) { bool bOK = false; _valType.SetDataType(new DataTypePointer(new TypePointer(typeof(Type)))); _valType.SetConstructorTypeScope(_var.ObjectType); DataTypePointer vType; if (_var.VariableLibType == null) { vType = new DataTypePointer(_var.VariableCustomType); } else { vType = new DataTypePointer(new TypePointer(_var.VariableLibType)); } DataTypePointer dp = _valType.ConstantValue.Value as DataTypePointer; if (dp != null) { bOK = vType.IsAssignableFrom(dp); } if (!bOK) { _valType.SetValue(vType); dp = vType; } if (!vType.IsAssignableFrom(_val.DataType)) { _val.SetDataType(dp); } } }
public ParameterValue CreateDefaultParameterValue(int i, IAction act) { ParameterValue p; if (i == 0) { p = new ParameterValue(act); p.Name = ConstObjectPointer.VALUE_Value; p.ParameterID = _property.MemberId; p.SetDataType(_property.PropertyType); p.ValueType = EnumValueType.Property; } else if (i == 1) { PropertyOverride po = _property as PropertyOverride; bool hasBaseVersion = (po != null && po.HasBaseImplementation); if (hasBaseVersion) { CustomPropertyOverridePointer cpop = new CustomPropertyOverridePointer(po, (ClassPointer)(_property.Owner)); p = new ParameterValue(act); p.Name = "BaseValue"; p.ParameterID = po.BasePropertyId; p.SetDataType(_property.PropertyType); p.ValueType = EnumValueType.Property; p.Property = cpop; } } else { p = null; } return(null); }
public ParameterValue CreateDefaultParameter(IProperty p) { ParameterValue pv = new ParameterValue(this.Action); pv.Name = p.ExpressionDisplay; pv.SetDataType(p.PropertyType); return(pv); }
public ParameterValue CreateDefaultParameterValue(int i) { ParameterValue pv = new ParameterValue(_action); pv.Name = PropName; pv.ParameterID = 0; pv.SetDataType(_prop.ObjectType); pv.ValueType = EnumValueType.ConstantValue; return(pv); }
private ParameterValue createValue() { ParameterValue value = new ParameterValue(_action); value.Name = PropertyValueName; value.ParameterID = (UInt32)PROPERTYID.GetHashCode(); if (_prop.PropertyType != null) { value.SetDataType(_prop.PropertyType); } else { value.SetDataType(new DataTypePointer(new TypePointer(typeof(object)))); } value.Property = new PropertyPointer(); //an empty property value.Property.Owner = this.Owner; value.ValueType = EnumValueType.ConstantValue; return(value); }
public ParameterValue CreateDefaultParameterValue(int i) { IParameter p = MethodParameterTypes[i]; ParameterValue pv = new ParameterValue(_action); pv.Name = p.Name; pv.ParameterID = p.ParameterID; ParameterClass pc = p as ParameterClass; if (pc != null) { pv.SetDataType(pc); } else { pv.SetDataType(p.ParameterLibType); } pv.SetOwnerAction(_action); pv.ValueType = EnumValueType.ConstantValue; return(pv); }
public ParameterValue CreateDefaultParameterValue(int i) { IParameter p = MethodParameterTypes[i]; ParameterValue pv = new ParameterValue(_action); pv.Name = p.Name; pv.ParameterID = p.ParameterID; pv.SetDataType(p.ParameterLibType); pv.MathExpression = _exp; pv.SetOwnerAction(_action); pv.ValueType = EnumValueType.MathExpression; return(pv); }
private void createValue() { _value = new ParameterValue(this); _value.Name = "Value"; _value.ParameterID = this.PropertyToSet.MemberId; _value.SetDataType(_prop.Property.PropertyType); _value.Property = new PropertyPointer(); _value.Property.Owner = this.Owner; _value.ValueType = EnumValueType.ConstantValue; //_value.ConstantValue = VPLUtil.GetDefaultValue(ObjectType); //_value.DataType = ObjectType; _value.SetParameterValueChangeEvent(new EventHandler(_value_PropertyChanged)); }
public override ParameterValue CreateDefaultParameterValue(int i) { ParameterInfo[] ps = this.Info; if (ps != null && ps.Length > i) { ParameterInfo p = ps[i]; ParameterValue pv = new ParameterValue(Action); pv.Name = p.Name; pv.ParameterID = (UInt32)(p.GetHashCode()); pv.SetDataType(p.ParameterType); pv.ValueType = EnumValueType.ConstantValue; return(pv); } return(null); }
public ParameterValue CreateDefaultParameterValue(int i) { IParameter p = MethodParameterTypes[i]; ParameterValue pv = new ParameterValue(_action); pv.Name = p.Name; pv.ParameterID = p.ParameterID; ParameterClass pc = p as ParameterClass; if (pc != null) { pv.SetDataType(pc); } else { pv.SetDataType(p.ParameterLibType); } pv.SetOwnerAction(_action); pv.ValueType = EnumValueType.Property; CustomMethodParameterPointer cmpp = new CustomMethodParameterPointer(pc); pv.SetValue(cmpp); return(pv); }
public void ValidateParameterValues(ParameterValueCollection parameters) { List <ParameterClass> ps = _event.GetParameters(this); if (ps.Count > 0) { if (ps[0].IsLibType && typeof(object).Equals(ps[0].BaseClassType)) { if (string.Compare("sender", ps[0].Name, StringComparison.OrdinalIgnoreCase) == 0) { if (parameters.Count == 0) { ParameterValue pv = new ParameterValue(_action); pv.Name = ps[0].Name; pv.SetDataType(typeof(object)); pv.ValueType = EnumValueType.Property; pv.Property = _event.RootPointer; parameters.Add(pv); } if (ps.Count > 1) { if (ps[1].IsLibType && typeof(EventArgs).Equals(ps[1].BaseClassType)) { if (parameters.Count < 2) { ParameterValue pv = new ParameterValue(_action); pv.Name = ps[1].Name; pv.SetDataType(typeof(EventArgs)); pv.ValueType = EnumValueType.Property; FieldPointer fp = new FieldPointer(); fp.Owner = new DataTypePointer(new TypePointer(typeof(EventArgs))); fp.MemberName = "Empty"; pv.Property = fp; parameters.Add(pv); } } } } } } ParameterValueCollection.ValidateParameterValues(parameters, ps, this); }
private void adjustParamType() { checkVariable(); if (_var != null) { bool bOK = false; _valType.SetDataType(new DataTypePointer(new TypePointer(typeof(Type)))); bool isString = (typeof(JsString).Equals(_var.BaseClassType) || typeof(PhpString).Equals(_var.BaseClassType)); _valType.SetConstructorTypeScope(_var.BaseClassType); DataTypePointer dp = _valType.ConstantValue.Value as DataTypePointer; if (dp != null) { bOK = _var.ClassType.IsAssignableFrom(dp); } if (!bOK) { _valType.SetValue(_var.ClassType); dp = _var.ClassType; } if (isString) { DataTypePointer st = new DataTypePointer(new TypePointer(typeof(string))); if (!st.IsAssignableFrom(_val.DataType)) { _val.SetDataType(st); } } else { if (!_var.ClassType.IsAssignableFrom(_val.DataType)) { _val.SetDataType(dp); } } } }
public void ValidateParameterValues(ParameterValueCollection parameters) { if (_prop == null) { FormWarning.ShowMessage("Error calling {0}.ValidateParameterValues. Property not set. Action:{1}", this.GetType().FullName, this.Action); } else { ParameterValue p = null; foreach (ParameterValue pv in parameters) { if (string.Compare(pv.Name, PropertyValueName, StringComparison.Ordinal) == 0) { p = pv; break; } } if (p == null) { p = createValue(); } if (_prop.PropertyType != null) { p.SetDataType(_prop.PropertyType); } IList <Attribute> ed = _prop.GetUITypeEditor(); if (ed != null && ed.Count > 0) { Attribute[] atts = new Attribute[ed.Count]; ed.CopyTo(atts, 0); p.MergeValueAttributes(atts); } parameters.Clear(); parameters.Add(p); } }
public virtual ParameterValue CreateDefaultParameterValue(int i) { ParameterInfo[] ps = this.Info; if (ps == null || i >= ps.Length) { return(null); } else { ParameterInfo p = ps[i]; ParameterValue pv = new ParameterValue(_action); if (string.IsNullOrEmpty(p.Name)) { pv.Name = "parameter" + i.ToString(); } else { pv.Name = p.Name; } pv.ParameterID = (UInt32)p.GetHashCode(); Type dt = null; if (p.ParameterType.IsGenericParameter) { if (GenericParameters != null && GenericParameters.Length > 0) { for (int k = 0; k < _genericParams.Length; k++) { if (_genericParams[k].Equals(p.ParameterType)) { if (TypeParameters == null) { throw new DesignerException("Error resolving generic parameter [{0}]. Concret types are not set", p.Name); } if (k < TypeParameters.Length) { dt = TypeParameters[k].BaseClassType; } else { throw new DesignerException("Error resolving generic parameter [{0}]. Concret types:[{1}]. Parameter position:[{2}]", p.Name, TypeParameters.Length, k); } break; } } } if (dt == null) { ILocalvariable lv = this.Owner as ILocalvariable; if (lv != null) { if (lv.ValueType == null) { throw new DesignerException("Error resolving generic parameter [{0}]. Data type for variable [{1}] is null", p.Name, lv); } DataTypePointer dtp = lv.ValueType.GetConcreteType(p.ParameterType); if (dtp != null) { dt = dtp.BaseClassType; } else { throw new DesignerException("Variable type [{0}] does not support generic parameter [{1}]", lv.ValueType, p.Name); } } else { IProperty ip = this.Owner as IProperty; if (ip != null) { if (ip.PropertyType == null) { throw new DesignerException("Error resolving generic parameter [{0}]. Data type for Property [{1}] is null", p.Name, ip); } DataTypePointer dtp = ip.PropertyType.GetConcreteType(p.ParameterType); if (dtp != null) { dt = dtp.BaseClassType; } else { throw new DesignerException("Property type [{0}] does not support generic parameter [{1}]", ip.PropertyType, p.Name); } } else { throw new DesignerException("Unsupported owner [{0}] for generic parameter [{1}]", this.Owner, p.Name); } } } } else { dt = p.ParameterType; } pv.SetDataType(dt); pv.ValueType = EnumValueType.ConstantValue; return(pv); } }