← Back to branch summary

~ubuntu-branches/ubuntu/lucid/monodevelop/lucid

« back to all changes in this revision

Viewing changes to src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/MemberCompletionData.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2010-01-10 14:25:59 UTC
  • mfrom: (1.2.5 upstream) (1.3.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100110142559-sorji5exvk9tyknr
Tags: 2.2+dfsg-2
* debian/rules/remove_support_for_non_debian_functionality.patch:
  + Also fix monodevelop-core-addins.pc to remove links to the
    addins we remove in Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/MemberCompletionData.cs
 
1
// MemberCompletionData.cs
 
2
//
 
3
// Author:
 
4
//   Mike Krüger <mkrueger@novell.com>
 
5
//
 
6
// Copyright (c) 2008 Novell, Inc (http://www.novell.com)
 
7
//
 
8
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
9
// of this software and associated documentation files (the "Software"), to deal
 
10
// in the Software without restriction, including without limitation the rights
 
11
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
12
// copies of the Software, and to permit persons to whom the Software is
 
13
// furnished to do so, subject to the following conditions:
 
14
//
 
15
// The above copyright notice and this permission notice shall be included in
 
16
// all copies or substantial portions of the Software.
 
17
//
 
18
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
19
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
20
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
21
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
22
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
23
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
24
// THE SOFTWARE.
 
25
//
 
26
 
 
27
using System;
 
28
using System.Collections.Generic;
 
29
using System.Text;
 
30
using System.Xml;
 
31
using MonoDevelop.Projects.Gui.Completion;
 
32
using MonoDevelop.Projects.Dom;
 
33
using MonoDevelop.Projects.Dom.Output;
 
34
 
 
35
using MonoDevelop.Core;
 
36
using MonoDevelop.Ide.Gui;
 
37
using MonoDevelop.Ide.Gui.Content;
 
38
using MonoDevelop.CSharp.Dom;
 
39
 
 
40
namespace MonoDevelop.CSharp.Completion
 
41
{
 
42
        public class MemberCompletionData : IMemberCompletionData, IOverloadedCompletionData
 
43
        {
 
44
                OutputFlags flags;
 
45
                bool hideExtensionParameter = true;
 
46
                static CSharpAmbience ambience = new CSharpAmbience ();
 
47
                bool descriptionCreated = false;
 
48
                
 
49
                string description, completionString;
 
50
                string displayText;
 
51
                
 
52
                Dictionary<string, ICompletionData> overloads;
 
53
                
 
54
                public string Description {
 
55
                        get {
 
56
                                CheckDescription ();
 
57
                                return description;
 
58
                        }
 
59
                }
 
60
                
 
61
                public string CompletionText {
 
62
                        get { return completionString; }
 
63
                        set { completionString = value; }
 
64
                }
 
65
                
 
66
                public INode Member {
 
67
                        get;
 
68
                        set;
 
69
                }
 
70
                
 
71
                public string DisplayText {
 
72
                        get {
 
73
                                if (displayText == null) {
 
74
                                        displayText = ambience.GetString (Member, flags | OutputFlags.HideGenericParameterNames);
 
75
                                }
 
76
 
 
77
                                return displayText; 
 
78
                        }
 
79
                }
 
80
                
 
81
                public string Icon {
 
82
                        get {
 
83
                                if (Member is IMember)
 
84
                                        return ((IMember)Member).StockIcon;
 
85
                                if (Member is IParameter)
 
86
                                        return ((IParameter)Member).StockIcon;
 
87
                                if (Member is LocalVariable)
 
88
                                        return ((LocalVariable)Member).StockIcon;
 
89
                                return "md-literal"; 
 
90
                        }
 
91
                }
 
92
                
 
93
                public DisplayFlags DisplayFlags { get; set; }
 
94
                
 
95
                public bool HideExtensionParameter {
 
96
                        get {
 
97
                                return hideExtensionParameter;
 
98
                        }
 
99
                        set {
 
100
                                hideExtensionParameter = value;
 
101
                        }
 
102
                }
 
103
                
 
104
                public MemberCompletionData (INode member, OutputFlags flags) 
 
105
                {
 
106
                        SetMember (member);
 
107
                        this.flags = flags;
 
108
                        DisplayFlags = DisplayFlags.DescriptionHasMarkup;
 
109
                        IMember m = Member as IMember;
 
110
                        if (m != null && m.IsObsolete)
 
111
                                DisplayFlags |= DisplayFlags.Obsolete;
 
112
                }
 
113
                
 
114
                void SetMember (INode member)
 
115
                {
 
116
                        this.Member = member;
 
117
                        if (member is IParameter) {
 
118
                                this.completionString = ((IParameter)member).Name;
 
119
                        } else {
 
120
                                this.completionString = ambience.GetString (member, flags & ~OutputFlags.IncludeGenerics);
 
121
                        }
 
122
                        descriptionCreated = false;
 
123
                        displayText = null;
 
124
                }
 
125
                
 
126
                void CheckDescription ()
 
127
                {
 
128
                        if (descriptionCreated)
 
129
                                return;
 
130
 
 
131
                        StringBuilder sb = new StringBuilder ();
 
132
 
 
133
                        descriptionCreated = true;
 
134
                        if (Member is IMethod && ((IMethod)Member).WasExtended)
 
135
                                sb.Append (GettextCatalog.GetString ("(Extension) "));
 
136
                        sb.Append (ambience.GetString (Member,
 
137
                                OutputFlags.ClassBrowserEntries | OutputFlags.IncludeKeywords | OutputFlags.UseFullName | OutputFlags.IncludeParameterName | OutputFlags.IncludeMarkup
 
138
                                        | (HideExtensionParameter ? OutputFlags.HideExtensionsParameter : OutputFlags.None)));
 
139
 
 
140
                        if (Member is IMember) {
 
141
                                if ((Member as IMember).IsObsolete) {
 
142
                                        sb.AppendLine ();
 
143
                                        sb.Append (GettextCatalog.GetString ("[Obsolete]"));
 
144
                                }
 
145
                                string docMarkup = AmbienceService.GetDocumentationMarkup ("<summary>" + AmbienceService.GetDocumentationSummary ((IMember)Member) + "</summary>", new AmbienceService.DocumentationFormatOptions {
 
146
                                        Ambience = ambience
 
147
                                });
 
148
                                if (!string.IsNullOrEmpty (docMarkup)) {
 
149
                                        sb.AppendLine ();
 
150
                                        sb.Append (docMarkup);
 
151
                                }
 
152
                        }
 
153
                        description = sb.ToString ();
 
154
                }
 
155
                
 
156
 
 
157
                #region IOverloadedCompletionData implementation 
 
158
                
 
159
                class OverloadSorter : IComparer<ICompletionData>
 
160
                {
 
161
                        OutputFlags flags = OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName;
 
162
                        
 
163
                        public int Compare (ICompletionData x, ICompletionData y)
 
164
                        {
 
165
                                INode mx = ((MemberCompletionData)x).Member;
 
166
                                INode my = ((MemberCompletionData)y).Member;
 
167
                                int result;
 
168
                                
 
169
                                if (mx is IType && my is IType) {
 
170
                                        result = ((((IType)mx).TypeParameters.Count).CompareTo (((IType)my).TypeParameters.Count));
 
171
                                        if (result != 0)
 
172
                                                return result;
 
173
                                }
 
174
                                
 
175
                                if (mx is IMethod && my is IMethod) {
 
176
                                        IMethod mmx = (IMethod) mx;//, mmy = (IMethod) my;
 
177
                                        result = (mmx.TypeParameters.Count).CompareTo (mmx.TypeParameters.Count);
 
178
                                        if (result != 0)
 
179
                                                return result;
 
180
                                        result = (mmx.Parameters.Count).CompareTo (mmx.Parameters.Count);
 
181
                                        if (result != 0)
 
182
                                                return result;
 
183
                                }
 
184
                                
 
185
                                string sx = ambience.GetString (mx, flags);
 
186
                                string sy = ambience.GetString (my, flags);
 
187
                                result = sx.Length.CompareTo (sy.Length);
 
188
                                return result == 0? string.Compare (sx, sy) : result;
 
189
                        }
 
190
                }
 
191
                
 
192
                public IEnumerable<ICompletionData> GetOverloadedData ()
 
193
                {
 
194
                        if (overloads == null)
 
195
                                return new ICompletionData[] { this };
 
196
                        
 
197
                        List<ICompletionData> sorted = new List<ICompletionData> (overloads.Values);
 
198
                        sorted.Add (this);
 
199
                        sorted.Sort (new OverloadSorter ());
 
200
                        return sorted;
 
201
                }
 
202
                
 
203
                public bool IsOverloaded {
 
204
                        get { return overloads != null && overloads.Count > 0; }
 
205
                }
 
206
                
 
207
                public void AddOverload (MemberCompletionData overload)
 
208
                {
 
209
                        if (overloads == null)
 
210
                                overloads = new Dictionary<string, ICompletionData> ();
 
211
                        if (overload.Member is IMember && Member is IMember) {
 
212
                                // filter virtual & overriden members that came from base classes
 
213
                                // note that the overload tree is traversed top down.
 
214
                                IMember member = Member as IMember;
 
215
                                if ((member.IsVirtual || member.IsOverride) && member.DeclaringType != null && ((IMember)overload.Member).DeclaringType != null && member.DeclaringType.DecoratedFullName != ((IMember)overload.Member).DeclaringType.DecoratedFullName) {
 
216
                                        string str1 = ambience.GetString (member, flags);
 
217
                                        string str2 = ambience.GetString (overload.Member, flags);
 
218
                                        if (str1 == str2) {
 
219
                                                if (string.IsNullOrEmpty (AmbienceService.GetDocumentationSummary ((IMember)Member)) && !string.IsNullOrEmpty (AmbienceService.GetDocumentationSummary ((IMember)overload.Member)))
 
220
                                                        SetMember (overload.Member);
 
221
                                                return;
 
222
                                        }
 
223
                                }
 
224
                                
 
225
                                string MemberId = (overload.Member as IMember).HelpUrl;
 
226
                                if (Member is IMethod && overload.Member is IMethod) {
 
227
                                        string signature1 = ambience.GetString (Member, OutputFlags.IncludeParameters);
 
228
                                        string signature2 = ambience.GetString (overload.Member, OutputFlags.IncludeParameters);
 
229
                                        if (signature1 == signature2)
 
230
                                                return;
 
231
                                }
 
232
                                
 
233
                                if (MemberId != (this.Member as IMember).HelpUrl && !overloads.ContainsKey (MemberId)) {
 
234
                                        if (((IMember)overload.Member).IsPartial)
 
235
                                                return;
 
236
                                        overloads[MemberId] = overload;
 
237
                                        
 
238
                                        //if any of the overloads is obsolete, we should not mark the item obsolete
 
239
                                        if (!(overload.Member as IMember).IsObsolete)
 
240
                                                DisplayFlags &= ~DisplayFlags.Obsolete;
 
241
                                        
 
242
                                        //make sure that if there are generic overloads, we show a generic signature
 
243
                                        if (overload.Member is IType && Member is IType && ((IType)Member).TypeParameters.Count == 0 && ((IType)overload.Member).TypeParameters.Count > 0) {
 
244
                                                displayText = overload.DisplayText;
 
245
                                        }
 
246
                                        if (overload.Member is IMethod && Member is IMethod && ((IMethod)Member).TypeParameters.Count == 0 && ((IMethod)overload.Member).TypeParameters.Count > 0) {
 
247
                                                displayText = overload.DisplayText;
 
248
                                        }
 
249
                                }
 
250
                        }
 
251
                }
 
252
                
 
253
                #endregion
 
254
        }
 
255
}