/// <summary>
/// Walks a method call. Typical method calls are:
///
/// @menuItem1.Items.AddRange(...)
///
/// This method will execute the method call.
/// </summary>
void WalkMethodCall(MethodCall node)
{
// Try to get the object being called. Try the form first then
// look for other controls.
object member = RubyControlFieldExpression.GetMember(component, node);
RubyControlFieldExpression field = RubyControlFieldExpression.Create(node);
if (member == null)
{
member = field.GetMember(componentCreator);
}
// Execute the method on the object.
if (member != null)
{
if (node.Arguments == null)
{
RegisterEventHandler(node, member);
}
else
{
object[] args = deserializer.GetArguments(node).ToArray();
InvokeMethod(member, field.MethodName, args);
}
}
}
object CreateInstance(string name, MethodCall methodCall)
{
RubyControlFieldExpression field = RubyControlFieldExpression.Create(methodCall);
Type type = GetType(field);
if (type != null)
{
if (type.IsEnum)
{
return(Enum.Parse(type, methodCall.MethodName));
}
BindingFlags propertyBindingFlags = BindingFlags.Public | BindingFlags.GetField | BindingFlags.Static | BindingFlags.Instance;
PropertyInfo propertyInfo = type.GetProperty(methodCall.MethodName, propertyBindingFlags);
if (propertyInfo != null)
{
return(propertyInfo.GetValue(type, null));
}
if (type.IsAssignableFrom(typeof(ComponentResourceManager)))
{
return(componentCreator.CreateInstance(type, new object[0], name, false));
}
if (methodCall.Arguments != null)
{
return(CreateInstance(type, name, methodCall));
}
}
else
{
return(componentCreator.GetInstance(field.MethodName));
}
return(null);
}
/// <summary>
/// Gets the fully qualified name of the base class.
/// </summary>
public static string GetBaseClassName(ClassDefinition classDefinition)
{
ConstantVariable variable = classDefinition.SuperClass as ConstantVariable;
if (variable != null)
{
return(RubyControlFieldExpression.GetQualifiedName(variable));
}
return(String.Empty);
}
public override bool Equals(object obj)
{
RubyControlFieldExpression rhs = obj as RubyControlFieldExpression;
if (rhs != null)
{
return(rhs.fullMemberName == fullMemberName && rhs.variableName == variableName);
}
return(false);
}
Type GetType(RubyControlFieldExpression field)
{
string typeName = field.FullMemberName;
if (!String.IsNullOrEmpty(typeName))
{
return(componentCreator.GetType(typeName));
}
return(null);
}
bool IsResource(Expression expression)
{
MethodCall methodCall = expression as MethodCall;
if (methodCall != null)
{
string memberName = RubyControlFieldExpression.GetMemberName(methodCall);
return(memberName.StartsWith("resources.", StringComparison.InvariantCultureIgnoreCase));
}
return(false);
}
static RubyControlFieldExpression Create(string[] memberNames)
{
string memberName = String.Empty;
if (memberNames.Length > 1)
{
memberName = memberNames[memberNames.Length - 1];
}
string fullMemberName = RubyControlFieldExpression.GetMemberName(memberNames);
return(new RubyControlFieldExpression(memberName, GetVariableNameFromSelfReference(fullMemberName), String.Empty, fullMemberName));
}
void ThrowCouldNotFindTypeException(Expression expression)
{
string typeName = String.Empty;
MethodCall methodCall = expression as MethodCall;
if (methodCall != null)
{
typeName = RubyControlFieldExpression.GetMemberName(methodCall);
}
string message = String.Format(StringParser.Parse("${res:ICSharpCode.PythonBinding.UnknownTypeName}"), typeName);
throw new RubyComponentWalkerException(message);
}
/// <summary>
/// Creates a RubyControlField from a call expression:
///
/// @menuItem1.Items.AddRange(...)
///
/// Note that in Ruby a method call is also of the form:
///
/// System::Drawing::Color.Red
/// </summary>
public static RubyControlFieldExpression Create(MethodCall methodCall)
{
string[] allNames = GetMemberNames(methodCall);
// Remove last member since it is the method name.
int lastItemIndex = allNames.Length - 1;
string[] memberNames = new string[lastItemIndex];
Array.Copy(allNames, memberNames, lastItemIndex);
RubyControlFieldExpression field = Create(memberNames);
field.methodName = allNames[lastItemIndex];
return(field);
}
/// <summary>
/// Deserializes a method call where the target is an array expression.
///
/// System::Array[System::String].new("a", "b")
/// </summary>
object DeserializeCreateArrayExpression(string name, MethodCall methodCall)
{
MethodCall arrayCreationMethodCall = methodCall.Target as MethodCall;
ConstantVariable constantVariable = arrayCreationMethodCall.Arguments.Expressions[0] as ConstantVariable;
string arrayTypeName = RubyControlFieldExpression.GetQualifiedName(constantVariable);
ArrayConstructor arrayConstructor = methodCall.Arguments.Expressions[0] as ArrayConstructor;
Expression[] arrayItems = arrayConstructor.Arguments.Expressions;
Type arrayType = componentCreator.GetType(arrayTypeName);
Array array = Array.CreateInstance(arrayType, arrayItems.Length);
for (int i = 0; i < arrayItems.Length; ++i)
{
Expression arrayItemExpression = arrayItems[i];
object instance = Deserialize(arrayItemExpression);
array.SetValue(instance, i);
}
return(array);
}
void WalkSimpleAssignment(SimpleAssignmentExpression node)
{
AttributeAccess attributeAccess = node.Left as AttributeAccess;
InstanceVariable instance = node.Left as InstanceVariable;
LocalVariable localVariable = node.Left as LocalVariable;
if (attributeAccess != null)
{
RubyControlFieldExpression field = RubyControlFieldExpression.Create(attributeAccess);
object propertyValue = deserializer.Deserialize(node.Right);
if (propertyValue != null)
{
field.SetPropertyValue(componentCreator, propertyValue);
}
else if (IsResource(node.Right))
{
field.SetPropertyValue(componentCreator, GetResource(node.Right as MethodCall));
}
else
{
ThrowCouldNotFindTypeException(node.Right);
}
}
else if (instance != null)
{
string instanceName = RubyControlFieldExpression.GetVariableName(instance.Name);
object propertyValue = deserializer.Deserialize(instanceName, node.Right);
AddComponent(instanceName, propertyValue);
}
else if (localVariable != null)
{
object propertyValue = deserializer.Deserialize(localVariable.Name, node.Right);
if (propertyValue == null)
{
ThrowCouldNotFindTypeException(node.Right);
}
}
}
public void LocalVariableMethodCall()
{
string code =
"listViewItem1 = System::Windows::Forms::ListViewItem.new()\r\n" +
"listViewItem1.CallMethod()\r\n";
MethodCall expression = RubyParserHelper.GetLastExpression(code) as MethodCall;
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression(String.Empty, String.Empty, "CallMethod", "listViewItem1");
Assert.AreEqual(expectedField, field);
}
public void LocalVariableCreatingNewInstance()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("listViewItem1 = System::Windows::Forms.ListViewItem.new()");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as LocalVariable);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression(String.Empty, "listViewItem1", String.Empty, "listViewItem1");
Assert.AreEqual(expectedField, field);
}
public void LocalVariableInAssignment()
{
SimpleAssignmentExpression expression = RubyParserHelper.GetSimpleAssignmentExpression("listViewItem1.TooltipText = \"abc\"");
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression.Left as AttributeAccess);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression("TooltipText", "listViewItem1", String.Empty, "listViewItem1.TooltipText");
Assert.AreEqual(expectedField, field);
}
public void UpperCaseClrMemberMethodCallIsConvertedToActualMemberNames()
{
string code =
"@pictureBox1.CLR_MEMBER(System::ComponentModel::ISupportInitialize, :BeginInit).call()\r\n";
MethodCall expression = RubyParserHelper.GetMethodCall(code);
RubyControlFieldExpression field = RubyControlFieldExpression.Create(expression);
RubyControlFieldExpression expectedField = new RubyControlFieldExpression(String.Empty, "pictureBox1", "BeginInit", "@pictureBox1");
Assert.AreEqual(expectedField, field);
}
void AssertAreEqual(RubyControlFieldExpression field, string variableName, string memberName, string methodName, string fullMemberName)
{
string expected = "Variable: " + variableName + " Member: " + memberName + " Method: " + methodName + " FullMemberName: " + fullMemberName;
string actual = "Variable: " + field.VariableName + " Member: " + field.MemberName + " Method: " + field.MethodName + " FullMemberName: " + field.FullMemberName;
Assert.AreEqual(expected, actual, actual);
}
Type GetType(RubyControlFieldExpression field)
{
string typeName = field.FullMemberName;
if (!String.IsNullOrEmpty(typeName)) {
return componentCreator.GetType(typeName);
}
return null;
}
