void FindReferences(object sender, EventArgs e)
        {
            MenuCommand item   = (MenuCommand)sender;
            IMember     member = (IMember)item.Tag;
            string      memberName;

            if (member is IProperty && ((IProperty)member).IsIndexer)
            {
                // The name of the default indexer is always "Indexer" in C#.
                // Add the type name to clarify which indexer is referred to.
                memberName = member.Name + " of " + member.DeclaringType.Name;
            }
            else
            {
                memberName = member.Name;
            }
            using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
            {
                FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
                                                                                     new string[, ] {
                    { "Name", memberName }
                }),
                                                                  RefactoringService.FindReferences(member, monitor));
            }
        }
        public override void Run()
        {
            var selectedItem = GetSelectedItems().FirstOrDefault();

            if (selectedItem == null)
            {
                return;
            }

            IClass c = GetClassFromName(selectedItem.FullyQualifiedClassName);

            if (c == null)
            {
                return;
            }

            IMember member = GetMemberFromName(c, selectedItem.MethodName, selectedItem.Parameters);

            if (member == null)
            {
                return;
            }

            string memberName = member.DeclaringType.Name + "." + member.Name;

            using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
            {
                FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
                                                                                     new string[, ] {
                    { "Name", memberName }
                }),
                                                                  RefactoringService.FindReferences(member, monitor));
            }
        }
Exemple #3
0
        void FindReferences(object sender, EventArgs e)
        {
            MenuCommand item       = (MenuCommand)sender;
            IMember     member     = (IMember)item.Tag;
            string      memberName = member.DeclaringType.Name + "." + member.Name;

            using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
            {
                FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
                                                                                     new string[, ] {
                    { "Name", memberName }
                }),
                                                                  RefactoringService.FindReferences(member, monitor));
            }
        }
        void FindReferences(object sender, EventArgs e)
        {
            MenuCommand item = (MenuCommand)sender;
            IClass      c    = (IClass)item.Tag;

            using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
            {
                FindReferencesAndRenameHelper.ShowAsSearchResults(
                    StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
                                       new string[, ] {
                    { "Name", c.Name }
                }),
                    RefactoringService.FindReferences(c, monitor)
                    );
            }
        }
        void ConvertToAutomaticProperty(ITextEditor editor, IProperty property, IField fieldDef, Ast.PropertyDeclaration astProp)
        {
            CodeGenerator codeGen = property.DeclaringType.ProjectContent.Language.CodeGenerator;

            int fieldStartOffset = editor.Document.PositionToOffset(fieldDef.Region.BeginLine, fieldDef.Region.BeginColumn);
            int fieldEndOffset   = editor.Document.PositionToOffset(fieldDef.Region.EndLine, fieldDef.Region.EndColumn);

            int startOffset = editor.Document.PositionToOffset(property.Region.BeginLine, property.Region.BeginColumn);
            int endOffset   = editor.Document.PositionToOffset(property.BodyRegion.EndLine, property.BodyRegion.EndColumn);

            ITextAnchor startAnchor = editor.Document.CreateAnchor(startOffset);
            ITextAnchor endAnchor   = editor.Document.CreateAnchor(endOffset);

            if (astProp.HasGetRegion)
            {
                astProp.GetRegion.Block = null;
            }

            if (!astProp.HasSetRegion)
            {
                astProp.SetRegion          = new Ast.PropertySetRegion(null, null);
                astProp.SetRegion.Modifier = CodeGenerator.ConvertModifier(fieldDef.Modifiers, new ClassFinder(fieldDef))
                                             & (Ast.Modifiers.Private | Ast.Modifiers.Internal | Ast.Modifiers.Protected | Ast.Modifiers.Public);
            }

            Ast.FieldDeclaration f = ParseMember <Ast.FieldDeclaration>(Path.GetExtension(editor.FileName),
                                                                        GetMemberText(fieldDef, editor));
            astProp.Initializer = f.Fields.First().Initializer;

            if (astProp.HasSetRegion)
            {
                astProp.SetRegion.Block = null;
            }
            using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.ConvertToAutomaticProperty}")) {
                var refs = RefactoringService.FindReferences(fieldDef, monitor);
                using (editor.Document.OpenUndoGroup()) {
                    FindReferencesAndRenameHelper.RenameReferences(refs, property.Name);
                    editor.Document.Remove(fieldStartOffset, fieldEndOffset - fieldStartOffset);
                    editor.Document.Replace(startAnchor.Offset, endAnchor.Offset - startAnchor.Offset, codeGen.GenerateCode(astProp, ""));
                }
            }
        }