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