← 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/Ambience.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/Ambience.cs
1
 
// Ambience.cs
2
 
//
3
 
// Author:
4
 
//   Lluis Sanchez Gual <lluis@novell.com>
5
 
//
6
 
// Copyright (c) 2006 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
 
 
28
 
using System;
29
 
using System.Collections;
30
 
using MonoDevelop.Core;
31
 
using MonoDevelop.Projects.Parser;
32
 
 
33
 
namespace MonoDevelop.Projects.Ambience
34
 
{
35
 
        public abstract class Ambience
36
 
        {               
37
 
                public static bool ShowAccessibility(ConversionFlags conversionFlags)
38
 
                {
39
 
                        return (conversionFlags & ConversionFlags.ShowAccessibility) == ConversionFlags.ShowAccessibility;
40
 
                }
41
 
                
42
 
                public static bool ShowReturnType (ConversionFlags conversionFlags)
43
 
                {
44
 
                        return (conversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType;
45
 
                }
46
 
                public static bool ShowParameters (ConversionFlags conversionFlags)
47
 
                {
48
 
                        return (conversionFlags & ConversionFlags.ShowParameters) == ConversionFlags.ShowParameters;
49
 
                }
50
 
                
51
 
 
52
 
                public static bool ShowParameterNames(ConversionFlags conversionFlags)
53
 
                {
54
 
                        return (conversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
55
 
                }
56
 
                
57
 
                public static bool UseFullyQualifiedNames(ConversionFlags conversionFlags)
58
 
                {
59
 
                        return (conversionFlags & ConversionFlags.UseFullyQualifiedNames) == ConversionFlags.UseFullyQualifiedNames;
60
 
                }
61
 
                
62
 
                public static bool UseIntrinsicTypeNames(ConversionFlags conversionFlags)
63
 
                {
64
 
                        return (conversionFlags & ConversionFlags.UseIntrinsicTypeNames) == ConversionFlags.UseIntrinsicTypeNames;
65
 
                }
66
 
                
67
 
                public static bool ShowMemberModifiers(ConversionFlags conversionFlags)
68
 
                {
69
 
                        return (conversionFlags & ConversionFlags.ShowMemberModifiers) == ConversionFlags.ShowMemberModifiers;
70
 
                }
71
 
                
72
 
                public static bool ShowInheritanceList(ConversionFlags conversionFlags)
73
 
                {
74
 
                        return (conversionFlags & ConversionFlags.ShowInheritanceList) == ConversionFlags.ShowInheritanceList;
75
 
                }
76
 
                
77
 
                public static bool IncludeHTMLMarkup(ConversionFlags conversionFlags)
78
 
                {
79
 
                        return (conversionFlags & ConversionFlags.IncludeHTMLMarkup) == ConversionFlags.IncludeHTMLMarkup;
80
 
                }
81
 
                
82
 
                public static bool IncludePangoMarkup(ConversionFlags conversionFlags)
83
 
                {
84
 
                        return (conversionFlags & ConversionFlags.IncludePangoMarkup) == ConversionFlags.IncludePangoMarkup;
85
 
                }
86
 
                
87
 
//              public static bool UseLinkArrayList(ConversionFlags conversionFlags)
88
 
//              {
89
 
//                      return (conversionFlags & ConversionFlags.UseLinkArrayList) == ConversionFlags.UseLinkArrayList;
90
 
//              }
91
 
                
92
 
                public static bool UseFullyQualifiedMemberNames(ConversionFlags conversionFlags)
93
 
                {
94
 
                        return UseFullyQualifiedNames(conversionFlags) && !((conversionFlags & ConversionFlags.QualifiedNamesOnlyForReturnTypes) == ConversionFlags.QualifiedNamesOnlyForReturnTypes);
95
 
                }
96
 
                
97
 
                public static bool IncludeBodies(ConversionFlags conversionFlags)
98
 
                {
99
 
                        return (conversionFlags & ConversionFlags.IncludeBodies) == ConversionFlags.IncludeBodies;
100
 
                }
101
 
                
102
 
                public static bool ShowClassModifiers(ConversionFlags conversionFlags)
103
 
                {
104
 
                        return (conversionFlags & ConversionFlags.ShowClassModifiers) == ConversionFlags.ShowClassModifiers;
105
 
                }
106
 
                
107
 
                public static bool ShowGenericParameters(ConversionFlags conversionFlags)
108
 
                {
109
 
                        return (conversionFlags & ConversionFlags.ShowGenericParameters) == ConversionFlags.ShowGenericParameters;
110
 
                }
111
 
                
112
 
                public string Convert(ILanguageItem item)
113
 
                {
114
 
                        return Convert (item, ConversionFlags.StandardConversionFlags);
115
 
                }
116
 
                
117
 
                public string Convert(ILanguageItem item, ConversionFlags conversionFlags)
118
 
                {
119
 
                        if (item is IClass)
120
 
                                return Convert (item as IClass, conversionFlags);
121
 
                        else if (item is IEvent)
122
 
                                return Convert (item as IEvent, conversionFlags);
123
 
                        else if (item is IField)
124
 
                                return Convert (item as IField, conversionFlags);
125
 
                        else if (item is IIndexer)
126
 
                                return Convert (item as IIndexer, conversionFlags);
127
 
                        else if (item is IMethod)
128
 
                                return Convert (item as IMethod, conversionFlags);
129
 
                        else if (item is IProperty)
130
 
                                return Convert (item as IProperty, conversionFlags);
131
 
                        else if (item is LocalVariable)
132
 
                                return Convert (item as LocalVariable, conversionFlags);
133
 
                        else
134
 
                                return item.Name;
135
 
                }
136
 
                
137
 
                public string Convert (IClass c)
138
 
                {
139
 
                        return Convert(c, ConversionFlags.StandardConversionFlags, null);
140
 
                }
141
 
                
142
 
                public string Convert (IClass c, ConversionFlags flags)
143
 
                {
144
 
                        return Convert(c, flags, null);
145
 
                }
146
 
                
147
 
                public string ConvertEnd (IClass c)
148
 
                {
149
 
                        return ConvertEnd (c, ConversionFlags.StandardConversionFlags);
150
 
                }
151
 
 
152
 
                public string Convert (IEvent e)
153
 
                {
154
 
                        return Convert(e, ConversionFlags.StandardConversionFlags, null);
155
 
                }
156
 
                
157
 
                public string Convert (IEvent e, ConversionFlags flags)
158
 
                {
159
 
                        return Convert(e, flags, null);
160
 
                }
161
 
                
162
 
                public string Convert (IField c)
163
 
                {
164
 
                        return Convert(c, ConversionFlags.StandardConversionFlags, null);
165
 
                }
166
 
                
167
 
                public string Convert (IField c, ConversionFlags flags)
168
 
                {
169
 
                        return Convert(c, flags, null);
170
 
                }
171
 
                
172
 
                public string Convert (IIndexer indexer)
173
 
                {
174
 
                        return Convert(indexer, ConversionFlags.StandardConversionFlags, null);
175
 
                }
176
 
                
177
 
                public string Convert (IIndexer indexer, ConversionFlags flags)
178
 
                {
179
 
                        return Convert(indexer, flags, null);
180
 
                }
181
 
                
182
 
                public string Convert (IMethod m)
183
 
                {
184
 
                        return Convert (m, ConversionFlags.StandardConversionFlags, null);
185
 
                }
186
 
                
187
 
                public string Convert (IMethod m, ConversionFlags flags)
188
 
                {
189
 
                        return Convert (m, flags, null);
190
 
                }
191
 
                
192
 
                public string ConvertEnd (IMethod m)
193
 
                {
194
 
                        return ConvertEnd(m, ConversionFlags.StandardConversionFlags);
195
 
                }
196
 
                
197
 
                public string Convert (IProperty property)
198
 
                {
199
 
                        return Convert (property, ConversionFlags.StandardConversionFlags, null);
200
 
                }
201
 
                
202
 
                public string Convert (IProperty property, ConversionFlags flags)
203
 
                {
204
 
                        return Convert (property, flags, null);
205
 
                }
206
 
                
207
 
                public string Convert (IParameter param)
208
 
                {
209
 
                        return Convert (param, ConversionFlags.StandardConversionFlags, null);
210
 
                }
211
 
                
212
 
                public string Convert (IParameter param, ConversionFlags flags)
213
 
                {
214
 
                        return Convert (param, flags, null);
215
 
                }
216
 
                
217
 
                public string Convert (IReturnType returnType)
218
 
                {
219
 
                        return Convert (returnType, ConversionFlags.StandardConversionFlags, null);
220
 
                }
221
 
                
222
 
                public string Convert (IReturnType returnType, ConversionFlags flags)
223
 
                {
224
 
                        return Convert (returnType, flags, null);
225
 
                }
226
 
                
227
 
                public string Convert (ModifierEnum modifier)
228
 
                {
229
 
                        return Convert(modifier, ConversionFlags.StandardConversionFlags);
230
 
                }
231
 
 
232
 
                public string Convert(LocalVariable localVariable)
233
 
                {
234
 
                        return Convert (localVariable, ConversionFlags.StandardConversionFlags, null);
235
 
                }
236
 
 
237
 
                public string Convert(LocalVariable localVariable, ConversionFlags flags)
238
 
                {
239
 
                        return Convert (localVariable, flags, null);
240
 
                }
241
 
 
242
 
                protected string GetResolvedTypeName (string dotNetTypeName, ConversionFlags flags, ITypeNameResolver resolver)
243
 
                {
244
 
                        if (UseIntrinsicTypeNames (flags)) {
245
 
                                string tn = GetIntrinsicTypeName (dotNetTypeName);
246
 
                                if (tn != null && tn != dotNetTypeName)
247
 
                                        return tn;
248
 
                        }
249
 
                        if (resolver != null) {
250
 
                                string tn = resolver.ResolveName (dotNetTypeName);
251
 
                                if (tn != null)
252
 
                                        return tn;
253
 
                        }
254
 
                        return dotNetTypeName;
255
 
                }
256
 
                
257
 
                public abstract string Convert (IClass c, ConversionFlags flags, ITypeNameResolver resolver);
258
 
                public abstract string ConvertEnd (IClass c, ConversionFlags flags);
259
 
                public abstract string Convert (IEvent e, ConversionFlags flags, ITypeNameResolver resolver);
260
 
                public abstract string Convert (IField c, ConversionFlags flags, ITypeNameResolver resolver);
261
 
                public abstract string Convert (IIndexer indexer, ConversionFlags flags, ITypeNameResolver resolver);
262
 
                public abstract string Convert (IMethod m, ConversionFlags flags, ITypeNameResolver resolver);
263
 
                public abstract string Convert (IProperty property, ConversionFlags flags, ITypeNameResolver resolver);
264
 
                public abstract string ConvertEnd (IMethod m, ConversionFlags flags);
265
 
                public abstract string Convert (IParameter param, ConversionFlags flags, ITypeNameResolver resolver);
266
 
                public abstract string Convert (IReturnType returnType, ConversionFlags flags, ITypeNameResolver resolver);
267
 
                public abstract string Convert (ModifierEnum modifier, ConversionFlags flags);
268
 
                public abstract string Convert (LocalVariable localVariable, ConversionFlags flags, ITypeNameResolver resolver);
269
 
                
270
 
                public abstract string WrapAttribute (string attribute);
271
 
                public abstract string WrapComment (string comment);
272
 
                public abstract string GetIntrinsicTypeName (string dotNetTypeName);
273
 
                
274
 
        }
275
 
}