← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric-updates

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Projects/MonoDevelop.Projects.Ambience/NetAmbience.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2009-02-18 08:40:51 UTC
  • mfrom: (1.2.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090218084051-gh8m6ukvokbwj7cf
Tags: 1.9.2+dfsg-1ubuntu1
https://launchpad.net/bugs/330519
* Merge from Debian Experimental (LP: #330519), remaining Ubuntu changes:
  + debian/control:
    - Update for Gnome# 2.24
    - Add libmono-cairo1.0-cil to build-deps to fool pkg-config check

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Projects/MonoDevelop.Projects.Ambience/NetAmbience.cs
1
 
//  NetAmbience.cs
2
 
//
3
 
//  This file was derived from a file from #Develop. 
4
 
//
5
 
//  Copyright (C) 2001-2007 Mike Krüger <mkrueger@novell.com>
6
 
// 
7
 
//  This program is free software; you can redistribute it and/or modify
8
 
//  it under the terms of the GNU General Public License as published by
9
 
//  the Free Software Foundation; either version 2 of the License, or
10
 
//  (at your option) any later version.
11
 
// 
12
 
//  This program is distributed in the hope that it will be useful,
13
 
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
 
//  GNU General Public License for more details.
16
 
//  
17
 
//  You should have received a copy of the GNU General Public License
18
 
//  along with this program; if not, write to the Free Software
19
 
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
 
 
21
 
using System;
22
 
using System.Text;
23
 
 
24
 
using MonoDevelop.Projects.Parser;
25
 
using MonoDevelop.Core;
26
 
 
27
 
namespace MonoDevelop.Projects.Ambience
28
 
{
29
 
        public class NetAmbience : Ambience
30
 
        {               
31
 
                public override string Convert(ModifierEnum modifier, ConversionFlags conversionFlags)
32
 
                {
33
 
                        return "";
34
 
                }
35
 
                
36
 
                public override string Convert (IClass c, ConversionFlags conversionFlags, ITypeNameResolver resolver)
37
 
                {
38
 
                        StringBuilder builder = new StringBuilder();
39
 
                        
40
 
                        if (ShowClassModifiers(conversionFlags)) {
41
 
                                switch (c.ClassType) {
42
 
                                        case ClassType.Delegate:
43
 
                                                builder.Append("Delegate");
44
 
                                                break;
45
 
                                        case ClassType.Class:
46
 
                                                builder.Append("Class");
47
 
                                                break;
48
 
                                        case ClassType.Struct:
49
 
                                                builder.Append("Structure");
50
 
                                                break;
51
 
                                        case ClassType.Interface:
52
 
                                                builder.Append("Interface");
53
 
                                                break;
54
 
                                        case ClassType.Enum:
55
 
                                                builder.Append("Enumeration");
56
 
                                                break;
57
 
                                }
58
 
                                builder.Append(' ');
59
 
                        }
60
 
                        
61
 
                        if (UseFullyQualifiedNames(conversionFlags))
62
 
                                builder.Append (c.FullyQualifiedName);
63
 
                        else
64
 
                                builder.Append (c.Name);
65
 
                        
66
 
                        if (c.GenericParameters != null && c.GenericParameters.Count > 0)
67
 
                        {
68
 
                                builder.Append("&lt;");
69
 
                                for (int i = 0; i < c.GenericParameters.Count; i++)
70
 
                                {
71
 
                                        builder.Append(c.GenericParameters[i].Name);
72
 
                                        if (i + 1 < c.GenericParameters.Count) builder.Append(", ");
73
 
                                }
74
 
                                builder.Append("&gt;");
75
 
                        }
76
 
                                
77
 
                        if (c.ClassType == ClassType.Delegate) {
78
 
                                builder.Append('(');
79
 
                                
80
 
                                foreach (IMethod m in c.Methods) {
81
 
                                        if (m.Name != "Invoke") continue;
82
 
                                        
83
 
                                        for (int i = 0; i < m.Parameters.Count; ++i) {
84
 
                                                builder.Append(Convert(m.Parameters[i]));
85
 
                                                if (i + 1 < m.Parameters.Count) {
86
 
                                                        builder.Append(", ");
87
 
                                                }
88
 
                                        }                                       
89
 
                                }
90
 
                                
91
 
                                builder.Append(')');
92
 
                                if (c.Methods.Count > 0) {
93
 
                                        builder.Append(" : ");
94
 
                                        builder.Append(Convert(c.Methods[0].ReturnType));
95
 
                                }
96
 
                        } else if (ShowInheritanceList(conversionFlags)) {
97
 
                                if (c.BaseTypes.Count > 0) {
98
 
                                        builder.Append(" : ");
99
 
                                        for (int i = 0; i < c.BaseTypes.Count; ++i) {
100
 
                                                builder.Append(c.BaseTypes[i]);
101
 
                                                if (i + 1 < c.BaseTypes.Count) {
102
 
                                                        builder.Append(", ");
103
 
                                                }
104
 
                                        }
105
 
                                }
106
 
                        }
107
 
                        
108
 
                        if (IncludeBodies(conversionFlags)) {
109
 
                                builder.Append("\n{");
110
 
                        }
111
 
                        
112
 
                        return builder.ToString();              
113
 
                }
114
 
                
115
 
                public override string ConvertEnd(IClass c, ConversionFlags conversionFlags)
116
 
                {
117
 
                        return "}";
118
 
                }
119
 
                
120
 
                public override string Convert(IField field, ConversionFlags conversionFlags, ITypeNameResolver resolver)
121
 
                {
122
 
                        StringBuilder builder = new StringBuilder();
123
 
                        if (ShowMemberModifiers(conversionFlags)) {
124
 
                                builder.Append("Field");
125
 
                                builder.Append(' ');
126
 
                        }
127
 
                        
128
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
129
 
                                builder.Append(field.FullyQualifiedName);
130
 
                        } else {
131
 
                                builder.Append(field.Name);
132
 
                        }
133
 
                        
134
 
                        if (field.ReturnType != null && ShowReturnType (conversionFlags)) {
135
 
                                builder.Append(" : ");
136
 
                                builder.Append(Convert(field.ReturnType));
137
 
                        }
138
 
                        
139
 
                        return builder.ToString();                      
140
 
                }
141
 
                
142
 
                public override string Convert(IProperty property, ConversionFlags conversionFlags, ITypeNameResolver resolver)
143
 
                {
144
 
                        StringBuilder builder = new StringBuilder();
145
 
                        if (ShowMemberModifiers(conversionFlags)) {
146
 
                                builder.Append("Property");
147
 
                                builder.Append(' ');
148
 
                        }
149
 
                        
150
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
151
 
                                builder.Append(property.FullyQualifiedName);
152
 
                        } else {
153
 
                                builder.Append(property.Name);
154
 
                        }
155
 
                        if (ShowParameters (conversionFlags)) {
156
 
                                if (property.Parameters.Count > 0) builder.Append('(');
157
 
                        
158
 
                                for (int i = 0; i < property.Parameters.Count; ++i) {
159
 
                                        builder.Append(Convert(property.Parameters[i]));
160
 
                                        if (i + 1 < property.Parameters.Count) {
161
 
                                                builder.Append(", ");
162
 
                                        }
163
 
                                }
164
 
                                
165
 
                                if (property.Parameters.Count > 0) builder.Append(')');
166
 
                        }
167
 
                        
168
 
                        
169
 
                        if (property.ReturnType != null && ShowReturnType (conversionFlags)) {
170
 
                                builder.Append(" : ");
171
 
                                builder.Append(Convert(property.ReturnType));
172
 
                        }
173
 
                        return builder.ToString();
174
 
                }
175
 
                
176
 
                public override string Convert(IEvent e, ConversionFlags conversionFlags, ITypeNameResolver resolver)
177
 
                {
178
 
                        StringBuilder builder = new StringBuilder();
179
 
                        if (ShowMemberModifiers(conversionFlags)) {
180
 
                                builder.Append("Event ");
181
 
                        }
182
 
                        
183
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
184
 
                                builder.Append(e.FullyQualifiedName);
185
 
                        } else {
186
 
                                builder.Append(e.Name);
187
 
                        }
188
 
                        if (e.ReturnType != null && ShowReturnType (conversionFlags)) {
189
 
                                builder.Append(" : ");
190
 
                                builder.Append(Convert(e.ReturnType));
191
 
                        }
192
 
                        return builder.ToString();
193
 
                }
194
 
                
195
 
                public override string Convert(IIndexer m, ConversionFlags conversionFlags, ITypeNameResolver resolver)
196
 
                {
197
 
                        StringBuilder builder = new StringBuilder();
198
 
                        if (ShowMemberModifiers(conversionFlags)) {
199
 
                                builder.Append("Indexer ");
200
 
                        }
201
 
                        
202
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
203
 
                                builder.Append(m.FullyQualifiedName);
204
 
                        } else {
205
 
                                builder.Append(m.Name);
206
 
                        }
207
 
                        builder.Append('[');
208
 
                        for (int i = 0; i < m.Parameters.Count; ++i) {
209
 
                                builder.Append(Convert(m.Parameters[i]));
210
 
                                if (i + 1 < m.Parameters.Count) {
211
 
                                        builder.Append(", ");
212
 
                                }
213
 
                        }
214
 
                        
215
 
                        builder.Append("]");
216
 
                        if (m.ReturnType != null && ShowReturnType (conversionFlags)) {
217
 
                                builder.Append(" : ");
218
 
                                builder.Append(Convert(m.ReturnType));
219
 
                        }
220
 
                        return builder.ToString();
221
 
                }
222
 
                
223
 
                public override string Convert(IMethod m, ConversionFlags conversionFlags, ITypeNameResolver resolver)
224
 
                {
225
 
                        StringBuilder builder = new StringBuilder();
226
 
                        if (ShowMemberModifiers(conversionFlags)) {
227
 
                                builder.Append("Method ");
228
 
                        }
229
 
                        
230
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
231
 
                                builder.Append(m.FullyQualifiedName);
232
 
                        } else {
233
 
                                builder.Append(m.Name);
234
 
                        }
235
 
                        if (ShowParameters (conversionFlags)) {                 
236
 
                                builder.Append('(');
237
 
                                for (int i = 0; i < m.Parameters.Count; ++i) {
238
 
                                        builder.Append(Convert(m.Parameters[i]));
239
 
                                        if (i + 1 < m.Parameters.Count) {
240
 
                                                builder.Append(", ");
241
 
                                        }
242
 
                                }
243
 
                                
244
 
                                builder.Append(")");
245
 
                        }
246
 
                        if (m.ReturnType != null && ShowReturnType (conversionFlags)) {
247
 
                                builder.Append(" : ");
248
 
                                builder.Append(Convert(m.ReturnType));
249
 
                        }
250
 
                        
251
 
                        if (IncludeBodies(conversionFlags)) {
252
 
                                builder.Append(" {");
253
 
                        }
254
 
                        
255
 
                        return builder.ToString();
256
 
                }
257
 
                
258
 
                public override string ConvertEnd(IMethod m, ConversionFlags conversionFlags)
259
 
                {
260
 
                        return "}";
261
 
                }       
262
 
                
263
 
                public override string Convert(IReturnType returnType, ConversionFlags conversionFlags, ITypeNameResolver resolver)
264
 
                {
265
 
                        if (returnType == null) {
266
 
                                return String.Empty;
267
 
                        }
268
 
                        StringBuilder builder = new StringBuilder();
269
 
                        
270
 
                        bool linkSet = false;
271
 
                        
272
 
                        //if (UseLinkArrayList(conversionFlags)) {
273
 
                                //SharpAssemblyReturnType ret = returnType as SharpAssemblyReturnType;
274
 
                                //if (ret != null) {
275
 
                                //      if (ret.UnderlyingClass != null) {
276
 
                                //              builder.Append("<a href='as://" + linkArrayList.Add(ret.UnderlyingClass) + "'>");
277
 
                                //              linkSet = true;
278
 
                                //      }
279
 
                                //}
280
 
                        //}
281
 
                        
282
 
                        if (UseFullyQualifiedNames(conversionFlags)) {
283
 
                                builder.Append(returnType.FullyQualifiedName);
284
 
                        } else {
285
 
                                builder.Append(returnType.Name);
286
 
                        }
287
 
                        
288
 
                        if (linkSet) {
289
 
                                builder.Append("</a>");
290
 
                        }
291
 
                        
292
 
                        for (int i = 0; i < returnType.PointerNestingLevel; ++i) {
293
 
                                builder.Append('*');
294
 
                        }
295
 
                        
296
 
                        for (int i = 0; i < returnType.ArrayCount; ++i) {
297
 
                                builder.Append('[');
298
 
                                for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) {
299
 
                                        builder.Append(',');
300
 
                                }
301
 
                                builder.Append(']');
302
 
                        }
303
 
                        
304
 
                        return builder.ToString();
305
 
                }
306
 
                
307
 
                public override string Convert(IParameter param, ConversionFlags conversionFlags, ITypeNameResolver resolver)
308
 
                {
309
 
                        StringBuilder builder = new StringBuilder();
310
 
                        if (ShowParameterNames(conversionFlags)) {
311
 
                                builder.Append(param.Name);
312
 
                        }
313
 
                        if (ShowReturnType (conversionFlags)) {
314
 
                                builder.Append(" : ");
315
 
                                builder.Append(Convert(param.ReturnType));
316
 
                        }
317
 
                        if (param.IsRef) {
318
 
                                builder.Append("&amp;");
319
 
                        }
320
 
                        return builder.ToString();
321
 
                }
322
 
 
323
 
                public override string Convert(LocalVariable localVariable, ConversionFlags conversionFlags, ITypeNameResolver resolver)
324
 
                {
325
 
                        StringBuilder builder = new StringBuilder();
326
 
 
327
 
                        builder.Append(localVariable.Name);
328
 
                        if (ShowReturnType (conversionFlags)) {
329
 
                                builder.Append(" : ");
330
 
                                builder.Append(Convert(localVariable.ReturnType));
331
 
                        }
332
 
 
333
 
                        return builder.ToString();
334
 
                }
335
 
 
336
 
                public override string WrapAttribute(string attribute)
337
 
                {
338
 
                        return "[" + attribute + "]";
339
 
                }
340
 
                
341
 
                public override string WrapComment(string comment)
342
 
                {
343
 
                        return "// " + comment;
344
 
                }
345
 
                
346
 
                public override string GetIntrinsicTypeName(string dotNetTypeName)
347
 
                {
348
 
                        return dotNetTypeName;
349
 
                }
350
 
        }
351
 
}