← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Main/Base/Project/Src/Services/RefactoringService/RefactorMenu.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Main/Base/Project/Src/Services/RefactoringService/RefactorMenu.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using ICSharpCode.SharpDevelop.Editor;
 
5
using System;
 
6
using System.Reflection;
 
7
using ICSharpCode.Core;
 
8
using ICSharpCode.SharpDevelop.Dom;
 
9
using ICSharpCode.SharpDevelop.Dom.Refactoring;
 
10
using ICSharpCode.SharpDevelop.Gui;
 
11
 
 
12
namespace ICSharpCode.SharpDevelop.Refactoring
 
13
{
 
14
        /// <summary>
 
15
        /// Tests if the refactoring provider for the current document
 
16
        /// supports the specified option.
 
17
        /// </summary>
 
18
        /// <attribute name="supports">
 
19
        /// Same of the action that should be supported.
 
20
        /// "*" to test if refactoring is supported at all.
 
21
        /// </attribute>
 
22
        /// <example title="Test if refactoring is supported">
 
23
        /// &lt;Condition name="RefactoringProviderSupports" supports="*"&gt;
 
24
        /// </example>
 
25
        /// <example title="Test if managing imports is supported">
 
26
        /// &lt;Condition name="RefactoringProviderSupports" supports="FindUnusedUsingDeclarations"&gt;
 
27
        /// </example>
 
28
        public class RefactoringProviderSupportsConditionEvaluator : IConditionEvaluator
 
29
        {
 
30
                public bool IsValid(object caller, Condition condition)
 
31
                {
 
32
                        if (WorkbenchSingleton.Workbench == null) {
 
33
                                return false;
 
34
                        }
 
35
                        ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
 
36
                        if (provider == null)
 
37
                                return false;
 
38
                        LanguageProperties language = ParserService.CurrentProjectContent.Language;
 
39
                        if (language == null)
 
40
                                return false;
 
41
                        if (string.IsNullOrEmpty(provider.TextEditor.FileName))
 
42
                                return false;
 
43
                        
 
44
                        RefactoringProvider rp = language.RefactoringProvider;
 
45
                        if (!rp.IsEnabledForFile(provider.TextEditor.FileName))
 
46
                                return false;
 
47
                        
 
48
                        string supports = condition.Properties["supports"];
 
49
                        if (supports == "*")
 
50
                                return true;
 
51
                        
 
52
                        Type t = rp.GetType();
 
53
                        try {
 
54
                                return (bool)t.InvokeMember("Supports" + supports, BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty, null, rp, null);
 
55
                        } catch (Exception ex) {
 
56
                                LoggingService.Warn(ex.ToString());
 
57
                                return false;
 
58
                        }
 
59
                }
 
60
        }
 
61
        
 
62
        public abstract class AbstractRefactoringCommand : AbstractMenuCommand
 
63
        {
 
64
                public override void Run()
 
65
                {
 
66
                        if (ParserService.LoadSolutionProjectsThreadRunning) {
 
67
                                return;
 
68
                        }
 
69
                        if (WorkbenchSingleton.Workbench == null) {
 
70
                                return;
 
71
                        }
 
72
                        ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
 
73
                        if (provider == null) return;
 
74
                        LanguageProperties language = ParserService.CurrentProjectContent.Language;
 
75
                        if (language == null) return;
 
76
                        
 
77
                        RefactoringProvider rp = language.RefactoringProvider;
 
78
                        Run(provider.TextEditor, rp);
 
79
                }
 
80
                
 
81
                protected ResolveResult ResolveAtCaret(ITextEditor textEditor)
 
82
                {
 
83
                        string fileName = textEditor.FileName;
 
84
                        IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
 
85
                        if (expressionFinder == null) return null;
 
86
                        string content = textEditor.Document.Text;
 
87
                        ExpressionResult expr = expressionFinder.FindFullExpression(content, textEditor.Caret.Offset);
 
88
                        if (expr.Expression == null) return null;
 
89
                        return ParserService.Resolve(expr, textEditor.Caret.Line, textEditor.Caret.Column, fileName, content);
 
90
                }
 
91
                
 
92
                protected abstract void Run(ITextEditor textEditor, RefactoringProvider provider);
 
93
        }
 
94
        
 
95
        public class RemoveUnusedUsingsCommand : AbstractRefactoringCommand
 
96
        {
 
97
                protected override void Run(ITextEditor textEditor, RefactoringProvider provider)
 
98
                {
 
99
                        using (var pm = Gui.AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.RemoveUnusedImports}")) {
 
100
                                NamespaceRefactoringService.ManageUsings(pm, textEditor.FileName, textEditor.Document, true, true);
 
101
                        }
 
102
                }
 
103
        }
 
104
        
 
105
        public class RenameCommand : AbstractRefactoringCommand
 
106
        {
 
107
                protected override void Run(ITextEditor textEditor, RefactoringProvider provider)
 
108
                {
 
109
                        ResolveResult rr = ResolveAtCaret(textEditor);
 
110
                        if (rr is MixedResolveResult) rr = (rr as MixedResolveResult).PrimaryResult;
 
111
                        if (rr is TypeResolveResult) {
 
112
                                Rename((rr as TypeResolveResult).ResolvedClass);
 
113
                        } else if (rr is MemberResolveResult) {
 
114
                                Rename((rr as MemberResolveResult).ResolvedMember);
 
115
                        } else if (rr is MethodGroupResolveResult) {
 
116
                                Rename((rr as MethodGroupResolveResult).GetMethodIfSingleOverload());
 
117
                        } else if (rr is LocalResolveResult) {
 
118
                                RenameLocalVariableCommand.Run(rr as LocalResolveResult);
 
119
                        } else {
 
120
                                ShowUnknownSymbolError();
 
121
                        }
 
122
                }
 
123
                
 
124
                static void ShowUnknownSymbolError()
 
125
                {
 
126
                        MessageService.ShowMessage("${res:SharpDevelop.Refactoring.CannotRenameElement}");
 
127
                }
 
128
                static void ShowNoUserCodeError()
 
129
                {
 
130
                        MessageService.ShowMessage("${res:SharpDevelop.Refactoring.CannotRenameBecauseNotUserCode}");
 
131
                }
 
132
                
 
133
                static void Rename(IMember member)
 
134
                {
 
135
                        if (member == null) {
 
136
                                ShowUnknownSymbolError();
 
137
                        } else if (member.DeclaringType.CompilationUnit.FileName == null) {
 
138
                                ShowNoUserCodeError();
 
139
                        } else {
 
140
                                IMethod method = member as IMethod;
 
141
                                if (method != null && method.IsConstructor) {
 
142
                                        Rename(method.DeclaringType);
 
143
                                } else {
 
144
                                        FindReferencesAndRenameHelper.RenameMember(member);
 
145
                                }
 
146
                        }
 
147
                }
 
148
                
 
149
                static void Rename(IClass c)
 
150
                {
 
151
                        if (c == null) {
 
152
                                ShowUnknownSymbolError();
 
153
                        } else if (c.CompilationUnit.FileName == null) {
 
154
                                ShowNoUserCodeError();
 
155
                        } else {
 
156
                                FindReferencesAndRenameHelper.RenameClass(c);
 
157
                        }
 
158
                }
 
159
        }
 
160
}