← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Content/CompletionTextEditorExtension.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.Ide/MonoDevelop.Ide.Gui.Content/CompletionTextEditorExtension.cs
29
29
using System;
30
30
using MonoDevelop.Projects;
31
31
using MonoDevelop.Projects.Gui.Completion;
32
 
using MonoDevelop.Projects.Parser;
33
 
using MonoDevelop.Projects.Ambience;
 
32
using MonoDevelop.Projects.Dom;
 
33
using MonoDevelop.Projects.Dom.Output;
 
34
using MonoDevelop.Projects.Dom.Parser;
34
35
using MonoDevelop.Components.Commands;
35
36
using MonoDevelop.Ide.Commands;
 
37
using MonoDevelop.Core;
36
38
 
37
39
namespace MonoDevelop.Ide.Gui.Content
38
40
{
41
43
                CodeCompletionContext currentCompletionContext;
42
44
                ICompletionWidget completionWidget;
43
45
                bool autoHideCompletionWindow = true;
44
 
                
 
46
                bool enableCodeCompletion = false;
 
47
 
45
48
                // When a key is pressed, and before the key is processed by the editor, this method will be invoked.
46
49
                // Return true if the key press should be processed by the editor.
47
 
                public override bool KeyPress (Gdk.Key key, Gdk.ModifierType modifier)
 
50
                public override bool KeyPress (Gdk.Key key, char keyChar, Gdk.ModifierType modifier)
48
51
                {
49
52
                        bool res;
50
53
                        
52
55
                                autoHideCompletionWindow = false;
53
56
                                if (CompletionWindowManager.ProcessKeyEvent (key, modifier)) {
54
57
                                        autoHideCompletionWindow = true;
55
 
                                        return true;
 
58
                                        return false;
56
59
                                }
57
60
                                autoHideCompletionWindow = false;
58
61
                        }
59
62
                        
60
63
                        if (ParameterInformationWindowManager.IsWindowVisible) {
61
64
                                if (ParameterInformationWindowManager.ProcessKeyEvent (key, modifier))
62
 
                                        return true;
 
65
                                        return false;
63
66
                                autoHideCompletionWindow = false;
64
67
                        }
65
68
                        
66
 
                        res = base.KeyPress (key, modifier);
 
69
                        res = base.KeyPress (key, keyChar, modifier);
 
70
                        if ((modifier & Gdk.ModifierType.ControlMask) == Gdk.ModifierType.ControlMask)
 
71
                                return res;
67
72
 
 
73
                        if (!enableCodeCompletion)
 
74
                                return res;
 
75
                        
68
76
                        // Handle code completion
69
 
                        
 
77
 
70
78
                        if (completionWidget != null && currentCompletionContext == null) {
71
79
                                currentCompletionContext = completionWidget.CreateCodeCompletionContext (Editor.CursorPosition);
72
 
                                ICompletionDataProvider cp = HandleCodeCompletion (currentCompletionContext, (char)(uint)key);
73
 
                                        
74
 
                                if (cp != null)
75
 
                                        CompletionWindowManager.ShowWindow ((char)(uint)key, cp, completionWidget, currentCompletionContext, OnCompletionWindowClosed);
76
 
                                else
 
80
                                
 
81
                                int triggerWordLength = currentCompletionContext.TriggerWordLength;
 
82
                                ICompletionDataList completionList = HandleCodeCompletion (currentCompletionContext, keyChar,
 
83
                                                                                           ref triggerWordLength);
 
84
 
 
85
                                if (triggerWordLength > 0 && (triggerWordLength < Editor.CursorPosition
 
86
                                                              || (triggerWordLength == 1 && Editor.CursorPosition == 1)))
 
87
                                {
 
88
                                        currentCompletionContext
 
89
                                                = completionWidget.CreateCodeCompletionContext (Editor.CursorPosition - triggerWordLength);     
 
90
                                        currentCompletionContext.TriggerWordLength = triggerWordLength;
 
91
                                }
 
92
                                
 
93
                                if (completionList != null) {
 
94
                                        if (!CompletionWindowManager.ShowWindow (keyChar, completionList, completionWidget, 
 
95
                                                                                 currentCompletionContext, OnCompletionWindowClosed))
 
96
                                                currentCompletionContext = null;
 
97
                                } else {
77
98
                                        currentCompletionContext = null;
 
99
                                }
78
100
                        }
79
101
                        
80
102
                        // Handle parameter completion
81
103
                        
82
 
                        if (ParameterInformationWindowManager.IsWindowVisible)
 
104
                        if (ParameterInformationWindowManager.IsWindowVisible) {
 
105
                                ParameterInformationWindowManager.CurrentCodeCompletionContext = Editor.CurrentCodeCompletionContext;
83
106
                                ParameterInformationWindowManager.PostProcessKeyEvent (key, modifier);
 
107
                        }
84
108
 
85
109
                        if (completionWidget != null) {
86
110
                                ICodeCompletionContext ctx = completionWidget.CreateCodeCompletionContext (Editor.CursorPosition);
87
 
                                IParameterDataProvider paramProvider = HandleParameterCompletion (ctx, (char)(uint)key);
 
111
                                IParameterDataProvider paramProvider = HandleParameterCompletion (ctx, keyChar);
88
112
                                if (paramProvider != null)
89
113
                                        ParameterInformationWindowManager.ShowWindow (ctx, paramProvider);
90
114
                        }
94
118
                        return res;
95
119
                }
96
120
                
 
121
                protected void ShowCompletion (ICompletionDataList completionList, int triggerWordLength, char keyChar)
 
122
                {
 
123
                        if (completionWidget != null && currentCompletionContext == null) {
 
124
                                currentCompletionContext = completionWidget.CreateCodeCompletionContext (Editor.CursorPosition);
 
125
                                if (triggerWordLength > 0 && triggerWordLength < Editor.CursorPosition) {
 
126
                                        currentCompletionContext =
 
127
                                                completionWidget.CreateCodeCompletionContext (Editor.CursorPosition - triggerWordLength);       
 
128
                                        currentCompletionContext.TriggerWordLength = triggerWordLength;
 
129
                                }
 
130
                                if (completionList != null)
 
131
                                        CompletionWindowManager.ShowWindow (keyChar, completionList, completionWidget, 
 
132
                                                                            currentCompletionContext, OnCompletionWindowClosed);
 
133
                                else
 
134
                                        currentCompletionContext = null;
 
135
                        }
 
136
                        autoHideCompletionWindow = true;
 
137
                }
 
138
                
97
139
                void OnCompletionWindowClosed ()
98
140
                {
99
141
                        currentCompletionContext = null;
123
165
                [CommandHandler (TextEditorCommands.ShowCompletionWindow)]
124
166
                public virtual void RunCompletionCommand ()
125
167
                {
126
 
                        ICompletionDataProvider cp = null;
 
168
                        ICompletionDataList completionList = null;
127
169
                        int cpos, wlen;
128
170
                        if (!GetCompletionCommandOffset (out cpos, out wlen)) {
129
171
                                cpos = Editor.CursorPosition;
131
173
                        }
132
174
                        currentCompletionContext = completionWidget.CreateCodeCompletionContext (cpos);
133
175
                        currentCompletionContext.TriggerWordLength = wlen;
134
 
                        cp = CodeCompletionCommand (currentCompletionContext);
 
176
                        completionList = CodeCompletionCommand (currentCompletionContext);
135
177
                                
136
 
                        if (cp != null)
137
 
                                CompletionWindowManager.ShowWindow ((char)0, cp, completionWidget, currentCompletionContext, OnCompletionWindowClosed);
 
178
                        if (completionList != null)
 
179
                                CompletionWindowManager.ShowWindow ((char)0, completionList, completionWidget, 
 
180
                                                                    currentCompletionContext, OnCompletionWindowClosed);
138
181
                        else
139
182
                                currentCompletionContext = null;
140
183
                }
149
192
                        ICodeCompletionContext ctx = completionWidget.CreateCodeCompletionContext (cpos);
150
193
                        cp = ParameterCompletionCommand (ctx);
151
194
 
152
 
                        if (cp != null)
 
195
                        if (cp != null) {
153
196
                                ParameterInformationWindowManager.ShowWindow (ctx, cp);
 
197
                                ParameterInformationWindowManager.PostProcessKeyEvent (Gdk.Key.F, Gdk.ModifierType.None);
 
198
                        }
154
199
                }
155
200
                
156
201
                public virtual bool CanRunCompletionCommand ()
163
208
                        return (completionWidget != null && !ParameterInformationWindowManager.IsWindowVisible);
164
209
                }
165
210
                
166
 
                public virtual ICompletionDataProvider HandleCodeCompletion (ICodeCompletionContext completionContext, char completionChar)
 
211
                
 
212
                public virtual ICompletionDataList HandleCodeCompletion (ICodeCompletionContext completionContext,
 
213
                                                                         char completionChar, ref int triggerWordLength)
 
214
                {
 
215
                        return HandleCodeCompletion (completionContext, completionChar);
 
216
                }
 
217
                
 
218
                public virtual ICompletionDataList HandleCodeCompletion (ICodeCompletionContext completionContext,
 
219
                                                                         char completionChar)
167
220
                {
168
221
                        return null;
169
222
                }
207
260
                        return false;
208
261
                }
209
262
 
210
 
                public virtual ICompletionDataProvider CodeCompletionCommand (ICodeCompletionContext completionContext)
 
263
                public virtual ICompletionDataList CodeCompletionCommand (ICodeCompletionContext completionContext)
211
264
                {
212
265
                        // This default implementation of CodeCompletionCommand calls HandleCodeCompletion providing
213
266
                        // the char at the cursor position. If it returns a provider, just return it.
215
268
                        int pos = completionContext.TriggerOffset;
216
269
                        string txt = Editor.GetText (pos - 1, pos);
217
270
                        if (txt.Length > 0) {
218
 
                                ICompletionDataProvider cp = HandleCodeCompletion (completionContext, txt[0]);
219
 
                                if (cp != null)
220
 
                                        return cp;
 
271
                                ICompletionDataList completionList = HandleCodeCompletion (completionContext, txt[0]);
 
272
                                if (completionList != null)
 
273
                                        return completionList;
221
274
                        }
222
275
                        
223
276
                        // If there is a parser context, try resolving by calling CtrlSpace.
224
 
                        IParserContext ctx = GetParserContext();
 
277
                        ProjectDom ctx = GetParserContext();
225
278
                        if (ctx != null) {
226
 
                                CodeCompletionDataProvider completionProvider = new CodeCompletionDataProvider (ctx, GetAmbience ());
227
 
                                completionProvider.AddResolveResults (ctx.CtrlSpace (completionContext.TriggerLine + 1, completionContext.TriggerLineOffset + 1, FileName), true, SimpleTypeNameResolver.Instance);
228
 
                                if (!completionProvider.IsEmpty)
229
 
                                        return completionProvider;
 
279
// TODO:
 
280
                                //CodeCompletionDataProvider completionProvider = new CodeCompletionDataProvider (ctx, GetAmbience ());
 
281
                                //completionProvider.AddResolveResults (ctx.CtrlSpace (completionContext.TriggerLine + 1, 
 
282
//                                              completionContext.TriggerLineOffset + 1, FileName), true, SimpleTypeNameResolver.Instance);
 
283
//                              if (!completionProvider.IsEmpty)
 
284
//                                      return completionProvider;
230
285
                        }
231
286
                        return null;
232
287
                }
250
305
                {
251
306
                        base.Initialize ();
252
307
                        
 
308
                        enableCodeCompletion = (bool)PropertyService.Get ("EnableCodeCompletion", true);
 
309
                        PropertyService.PropertyChanged += OnPropertyUpdated;
253
310
                        completionWidget = Document.GetContent <ICompletionWidget> ();
254
311
                        if (completionWidget != null)
255
312
                                completionWidget.CompletionContextChanged += OnCompletionContextChanged;
256
313
                }
257
 
        }
258
 
        
 
314
 
 
315
                bool disposed;
 
316
                public override void Dispose ()
 
317
                {
 
318
                        if (!disposed) {
 
319
                                disposed = false;
 
320
                                PropertyService.PropertyChanged -= OnPropertyUpdated;
 
321
                                base.Dispose ();
 
322
                        }
 
323
                }
 
324
 
 
325
                void OnPropertyUpdated (object sender, PropertyChangedEventArgs e)
 
326
                {
 
327
                        if (e.Key == "EnableCodeCompletion" && e.NewValue != e.OldValue)
 
328
                                enableCodeCompletion  = (bool)e.NewValue;
 
329
                }       
 
330
        }
 
331
        public interface ITypeNameResolver
 
332
        {
 
333
                string ResolveName (string typeName);
 
334
        }
259
335
        class SimpleTypeNameResolver: ITypeNameResolver
260
336
        {
261
337
                // This simple resolver removes the namespace from all class names.