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