Exemple #1
0
        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);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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);
                }
            }
        }
Exemple #5
0
        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;
 }