private IConstructorDeclaration CreateConstructor(IClassDeclaration classDeclaration, IIdentifier fieldIdentifier, ITypeName typeName)
{
IConstructLanguage language = classDeclaration.Language;
IParameter parameter = language.Parameter(typeName);
NamingPolicy parameterNamingPolicy = parameter.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
string parameterName = parameterNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);
parameter.Identifier = language.Identifier(parameterName);
Modifiers constructorModifiers = Modifiers.Public;
Modifiers visibility = classDeclaration.Modifiers.Modifiers.GetVisibility();
if (visibility == Modifiers.None || visibility.IsInternal())
{
constructorModifiers = Modifiers.Internal;
}
IConstructorDeclaration constructor = language.Constructor(language.None <IDocComment>(),
language.None <IAttributes>(),
language.Modifiers(constructorModifiers),
language.Parameters(parameter),
language.None <IConstructorInitializer>(),
language.Block(
language.AssignmentStatement(
language.MemberAccess(language.This(), fieldIdentifier),
language.VariableAccess(parameter.Identifier))));
return(constructor);
}
private IFieldDeclaration CreateFieldToHoldWrappedClass(IConstructLanguage language, ITypeName typeName, IClassDeclaration classDeclaration)
{
IFieldDeclaration fieldDeclaration = language.Field(language.Modifiers(Modifiers.Private | Modifiers.Readonly), typeName);
NamingPolicy fieldsNamingPolicy = fieldDeclaration.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
string fieldName = fieldsNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);
fieldDeclaration.Identifier = language.Identifier(fieldName);
return(fieldDeclaration);
}
private IClassDeclaration CreateInitialViewModel(IClassDeclaration classDeclaration, IFieldDeclaration fieldDeclaration, IConstructorDeclaration viewModelConstructor)
{
IConstructLanguage language = classDeclaration.Language;
IClassDeclaration viewModel = language.Class(
language.Modifiers(Modifiers.Public),
language.None <IClassTypeParameters>(),
language.None <ITypeName>(),
new List <ITypeName>(),
new List <IDeclaration>()
{
fieldDeclaration, viewModelConstructor
});
NamingPolicy classesPolicy = viewModel.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
string viewModelName = classesPolicy.MakeTypeNameUniqueInNamespace(classDeclaration, classDeclaration.Identifier.Name + "ViewModel");
viewModel.Identifier = language.Identifier(viewModelName);
return(viewModel);
}
public override void Execute(SolutionModel solutionModel, SelectionContext context)
{
FileModel fileModel;
CodeSpan selection;
if (!solutionModel.IsEditorSelection(context, out fileModel, out selection))
{
return;
}
IConstructEnumerable <IFieldDeclaration> fields = FindFields(fileModel, selection);
if (fields.Exist())
{
IConstructLanguage language = fields.Language;
foreach (IFieldDeclaration field in fields)
{
IPropertyDeclaration property = language.Property(
language.None <IDocComment>(),
language.None <IAttributes>(),
language.Modifiers(Modifiers.Public),
language.TypeName(field.TypeName.Type),
language.None <IIdentifier>());
NamingPolicy propertyNamingPolicy = property.PrimaryNamingPolicy(fileModel.UserSettings);
string propertyName = propertyNamingPolicy.MakeMemberNameUniqueInScope(field, field.Identifier.Name);
property.Identifier = language.Identifier(propertyName);
IAccessor getter = language.FieldGetter(field.Identifier);
IAccessor setter = CreateSetter(language, propertyName, field);
property.Accessors = language.Enumerable(new List <IAccessor>()
{
getter, setter
});
field.EnclosingClass.Insert(property);
}
}
}
private void InsertWrappedProperties(IClassDeclaration viewModel, List <IPropertyDeclaration> confirmedPropertiesForWrapping, IFieldDeclaration wrappedClassField, IIdentifier onPropertyChangedIdentifier)
{
IConstructLanguage language = viewModel.Language;
foreach (IPropertyDeclaration property in confirmedPropertiesForWrapping)
{
IMemberAccess propertyMemberAccess = language.MemberAccess(
language.MemberAccess(language.None <IExpression>(), wrappedClassField.Identifier),
property.Identifier);
IAccessor getterOfWrapper = language.None <IAccessor>();
IAccessor propertyGetter = property.Getter();
if (propertyGetter.Exists && IsAccessorVisibleOutsideClass(propertyGetter.Modifiers))
{
getterOfWrapper = language.Getter(
language.Modifiers(propertyGetter.Modifiers.Modifiers),
language.Block(
language.ReturnStatement(propertyMemberAccess)));
}
IAccessor setterOfWrapper = language.None <IAccessor>();
IAccessor propertySetter = property.Setter();
if (propertySetter.Exists && IsAccessorVisibleOutsideClass(propertySetter.Modifiers))
{
IStatement assignment = language.AssignmentStatement(propertyMemberAccess, language.Expression("value"));
IMethodInvocation onPropertyChangedInvocation =
language.MethodInvocation(
language.None <IExpression>(),
onPropertyChangedIdentifier,
language.None <ITypeArguments>(),
language.Arguments(
language.Argument(language.StringLiteral(property.Identifier.Name))));
IIfStatement ifStatement =
language.IfStatement(
language.BinaryExpression(propertyMemberAccess,
Operator.NotEqual,
language.Expression("value")),
language.Block(assignment, language.ExpressionStatement(onPropertyChangedInvocation)));
setterOfWrapper = language.Setter(
language.Modifiers(propertyGetter.Modifiers.Modifiers),
language.Block(ifStatement));
}
if (getterOfWrapper.Exists || setterOfWrapper.Exists)
{
IPropertyDeclaration wrapperProperty = language.Property(
language.None <IDocComment>(),
language.None <IAttributes>(),
property.Modifiers,
property.TypeName,
property.Identifier,
getterOfWrapper,
setterOfWrapper);
viewModel.Insert(wrapperProperty);
}
}
}
private IFieldDeclaration CreateFieldToHoldWrappedClass(IConstructLanguage language, ITypeName typeName, IClassDeclaration classDeclaration)
{
IFieldDeclaration fieldDeclaration = language.Field(language.Modifiers(Modifiers.Private | Modifiers.Readonly), typeName);
NamingPolicy fieldsNamingPolicy = fieldDeclaration.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
string fieldName = fieldsNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);
fieldDeclaration.Identifier = language.Identifier(fieldName);
return fieldDeclaration;
}