public ParameterDataProvider(Document doc, CodeCompletionContext context)
        {
            this.doc = doc;

            string basepath = (null == doc.Project)?
                doc.FileName.FullPath.ParentDirectory:
                doc.Project.BaseDirectory.FullPath;
            string contents = doc.Editor.Text;
            string line = doc.Editor.GetLineText (context.TriggerLine);
            method = RubyCompletion.GetSymbol (contents, context.TriggerOffset-1);
            int methodIndex = line.IndexOf (method, 0);

            // Console.WriteLine ("HandleParameterCompletion ({0} {1})", line, methodIndex);

            if (0 < methodIndex) {
                int end = line.LastIndexOfAny (RubyCompletion.wordBreakChars, methodIndex);
                int start = -1;
                if (0 < end) {
                    start = line.LastIndexOfAny (RubyCompletion.wordBreakChars, end-1)+1;
                    if (0 <= start) {
                        owner = line.Substring (start, end-start);
                    }
                }
                // Console.WriteLine ("Owner: {0}-{1}", start, end);
            }

            if ("def".Equals (owner, StringComparison.Ordinal) || 0 <= Array.IndexOf (RubyCompletion.reservedWords, method)) {
                method = owner = string.Empty;
                methodParams = new string[0];
                return;
            }

            methodParams = RubyCompletion.GetMethodArguments (basepath, contents, context.TriggerLine-1, owner, method);
            Valid = (null != methodParams);
        }
Example #2
0
		// Returns the index of the parameter where the cursor is currently positioned.
		// -1 means the cursor is outside the method parameter list
		// 0 means no parameter entered
		// > 0 is the index of the parameter (1-based)
		public int GetCurrentParameterIndex (ICompletionWidget widget, CodeCompletionContext ctx)
		{
			int cursor = widget.CurrentCodeCompletionContext.TriggerOffset;
			int i = ctx.TriggerOffset;
			if (i < 0 || i >= editor.Length || editor.GetCharAt (i) == ')')
				return -1;
			
			if (i > cursor)
				return -1;
			else if (i == cursor)
				return 0;
			
			int parameterIndex = 1;
			
			while (i++ < cursor) {
				if (i >= widget.TextLength)
					break;
				char ch = widget.GetChar (i);
				if (ch == ',')
					parameterIndex++;
				else if (ch == ')')
					return -1;
			}
			
			return parameterIndex;
		}
        public override IParameterDataProvider HandleParameterCompletion(CodeCompletionContext completionContext, char completionChar)
        {
            if (mCompletionEnabled)
            {
                // HandleCodeCompletion is always called first, so we don't need to fetch completion data

                if (completionChar == ')' || completionContext.TriggerLine != mCacheTriggerLine)
                {
                    // invalidate cached completion
                    mCacheXML = null;
                }

                if (!mCacheIsObject && mCacheXML != null)
                {
                    if (parameterDataProvider == null)
                    {
                        parameterDataProvider = new HaxeParameterDataProvider ();
                        parameterDataProvider.Update (completionContext, mCacheXML);
                        return parameterDataProvider;
                    }
                }
                else
                {
                    if (parameterDataProvider != null)
                    {
                        parameterDataProvider.Clear ();
                        parameterDataProvider = null;
                    }
                }
            }

            return null;
        }
		public void Update (CodeCompletionContext completionContext, XmlDocument data)
		{
			//showCompletion = true;
			offset = completionContext.TriggerOffset;
			
			signature = data.FirstChild.InnerText.Trim ();
			
			//MonoDevelop.Ide.MessageService.ShowError (signature);
			
			signature = signature.Replace (" ", "");
			signature = signature.Replace ("<", "&lt;");
			signature = signature.Replace (">", "&gt;");

			string[] splitByOpenParen = signature.Split ('(');
			signature = "";

			for (int i = 0; i < splitByOpenParen.Length; i++) {

				string[] splitByCloseParen = splitByOpenParen[i].Split (')');

				for (int j = 0; j < splitByCloseParen.Length; j++) {

					if (i > 0 && j == 0) {

						signature += splitByCloseParen[0].Replace ("-&gt;", "->");

					} else {

						signature += splitByCloseParen[i];

					}

				}

			}
			
			//string[] splitByColon = signature.Split (':');
			
			//if (splitByColon.Length > 1) {
				
				//parameterName = splitByColon[0];
				//signature = splitByColon[1];
				
			//}
			
			//MonoDevelop.Ide.MessageService.ShowError (parameterName);
			//MonoDevelop.Ide.MessageService.ShowError (signature);
			
			parameters = signature.Split (new string[] { "-&gt;" }, StringSplitOptions.None);

			for (int i = 0; i < parameters.Length; i++) {

				parameters[i] = parameters[i].Replace ("->", " -&gt; ");
				//MonoDevelop.Ide.MessageService.ShowError (parameters[i]);

			}
			
			//MonoDevelop.Ide.MessageService.ShowError (parameters.Length.ToString ());
			//MonoDevelop.Ide.MessageService.ShowError (parameters.ToString ());
		}
		public Task<ICompletionDataList> HandleCompletion (MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context,	CodeCompletionContext completionContext,
			UnderlyingDocumentInfo docInfo, char currentChar, CancellationToken token)
		{
			CodeCompletionContext ccc;
			var completion = CreateCompletionAndUpdate (editor, context, docInfo, out ccc);
			return completion.HandleCodeCompletionAsync (completionContext, currentChar, token);
		}
		CSharpCompletionTextEditorExtension CreateCompletionAndUpdate (MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context, UnderlyingDocumentInfo docInfo,
			out CodeCompletionContext codeCompletionContext)
		{
			var completion = CreateCompletion (editor, context, docInfo, out codeCompletionContext);
			completion.UpdateParsedDocument ();
			return completion;
		}
		public static bool ShowWindow (char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate)
		{
			try {
				if (wnd == null) {
					wnd = new CompletionListWindow ();
					wnd.WordCompleted += HandleWndWordCompleted;
				}
				try {
					if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext, closedDelegate)) {
						if (list is IDisposable)
							((IDisposable)list).Dispose ();
						DestroyWindow ();
						return false;
					}
					
					if (ForceSuggestionMode)
						wnd.AutoSelect = false;
					
					OnWindowShown (EventArgs.Empty);
					return true;
				} catch (Exception ex) {
					LoggingService.LogError (ex.ToString ());
					return false;
				}
			} finally {
				ParameterInformationWindowManager.UpdateWindow (completionWidget);
			}
		}
        public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char triggerChar, ref int triggerWordLength)
        {
            var l = new CompletionDataList();

            if (!(triggerChar==' ' ||
                char.IsLetter(triggerChar) ||
                triggerChar == '@' ||
                triggerChar == '(' ||
                triggerChar == '_' ||
                triggerChar == '.' ||
                triggerChar == '\0'))
                return l;

            triggerWordLength = (char.IsLetter(triggerChar) || triggerChar=='_' || triggerChar=='@') ? 1 : 0;

            // Require a parsed D source

            var dom = base.Document.ParsedDocument as ParsedDModule;
            if (dom != null && dom.DDom!=null)
                lock(dom.DDom)
                DCodeCompletionSupport.BuildCompletionData(
                    Document,
                    dom.DDom,
                    completionContext,
                    l,
                    triggerChar);

            return l;
        }
		CSharpCompletionTextEditorExtension CreateCompletionAndUpdate (Document realDocument, UnderlyingDocumentInfo docInfo,
			out CodeCompletionContext codeCompletionContext)
		{
			var completion = CreateCompletion (realDocument, docInfo, out codeCompletionContext);
			completion.UpdateParsedDocument ();
			return completion;
		}
		// ext may be null, but then parameter completion don't work
		public static bool ShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
		{
			try {
				if (ext != null) {
					int inserted = ext.document.Editor.EnsureCaretIsNotVirtual ();
					if (inserted > 0)
						completionContext.TriggerOffset = ext.document.Editor.Caret.Offset;
				}
				if (wnd == null) {
					wnd = new CompletionListWindow ();
					wnd.WordCompleted += HandleWndWordCompleted;
				}
				wnd.Extension = ext;
				try {
					if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext)) {
						if (list is IDisposable)
							((IDisposable)list).Dispose ();
						HideWindow ();
						return false;
					}
					
					if (ForceSuggestionMode)
						wnd.AutoSelect = false;
					wnd.Show ();
					DesktopService.RemoveWindowShadow (wnd);
					OnWindowShown (EventArgs.Empty);
					return true;
				} catch (Exception ex) {
					LoggingService.LogError (ex.ToString ());
					return false;
				}
			} finally {
				ParameterInformationWindowManager.UpdateWindow (ext, completionWidget);
			}
		}
		public ICompletionDataList HandleCompletion (Document realDocument,	CodeCompletionContext completionContext,
			UnderlyingDocumentInfo docInfo, char currentChar, ref int triggerWordLength)
		{
			CodeCompletionContext ccc;
			var completion = CreateCompletionAndUpdate (realDocument, docInfo, out ccc);
			return completion.HandleCodeCompletion (completionContext, currentChar, ref triggerWordLength);
		}
Example #12
0
        public static EditorData CreateEditorData(Document EditorDocument, DModule Ast, CodeCompletionContext ctx, char triggerChar = '\0')
        {
            bool removeChar = char.IsLetter(triggerChar) || triggerChar == '_';

            var deltaOffset = 0;//removeChar ? 1 : 0;

            var caretOffset = ctx.TriggerOffset - (removeChar ? 1 : 0);
            var caretLocation = new CodeLocation(ctx.TriggerLineOffset - deltaOffset, ctx.TriggerLine);
            var codeCache = CreateCacheList(EditorDocument);

            var ed = new EditorData
            {
                CaretLocation = caretLocation,
                CaretOffset = caretOffset,
                ModuleCode = removeChar ? EditorDocument.Editor.Text.Remove(ctx.TriggerOffset - 1, 1) : EditorDocument.Editor.Text,
                SyntaxTree = Ast,
                ParseCache = codeCache
            };

            if (EditorDocument.HasProject)
            {
                var cfg = EditorDocument.Project.GetConfiguration(IdeApp.Workspace.ActiveConfiguration);

                if (cfg is DProjectConfiguration)
                {
                    var dcfg = cfg as DProjectConfiguration;
                    ed.GlobalDebugIds = dcfg.CustomDebugIdentifiers;
                    ed.IsDebug = dcfg.DebugMode;
                    ed.DebugLevel = dcfg.DebugLevel;
                    ed.GlobalVersionIds = dcfg.GlobalVersionIdentifiers;
                    double d;
                    ulong v;
                    if (Double.TryParse(EditorDocument.Project.Version, out d))
                        ed.VersionNumber = (ulong)d;
                    else if (UInt64.TryParse(EditorDocument.Project.Version, out v))
                        ed.VersionNumber = v;
                }
                else if (cfg is DubProjectConfiguration)
                {
                    var versions = new List<string>(VersionIdEvaluation.GetOSAndCPUVersions());

                    var dcfg = cfg as DubProjectConfiguration;
                    ed.IsDebug = dcfg.DebugMode;

                    HandleDubSettingsConditionExtraction(versions, (dcfg.ParentItem as DubProject).CommonBuildSettings);
                    HandleDubSettingsConditionExtraction(versions, dcfg.BuildSettings);

                    ed.GlobalVersionIds = versions.ToArray();
                }
            }

            if (ed.GlobalVersionIds == null)
            {
                ed.GlobalVersionIds = VersionIdEvaluation.GetOSAndCPUVersions();
            }

            return ed;
        }
		public override ICompletionDataList HandleCodeCompletion (CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength)
		{
			var pathCompletion = HandlePathCompletion ();
			if (pathCompletion != null) {
				return pathCompletion;
			}

			return base.HandleCodeCompletion (completionContext, completionChar, ref triggerWordLength);
		}
		public override ICompletionDataProvider HandleCodeCompletion (
		    CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength)
		{
			int pos = completionContext.TriggerOffset;
			if (pos > 0 && Editor.GetCharAt (pos - 1) == completionChar) {
				return HandleCodeCompletion ((CodeCompletionContext) completionContext, false, ref triggerWordLength);
			}
			return null;
		}
        public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx)
        {
            if (showCompletion)
            {
                return 0;
            }

            return -1;
        }
		public override Task<ICompletionDataList> HandleCodeCompletionAsync (CodeCompletionContext completionContext, char completionChar, CancellationToken token = default(CancellationToken))
		{
			var pathCompletion = HandlePathCompletion ();
			if (pathCompletion != null) {
				return Task.FromResult (pathCompletion);
			}

			return base.HandleCodeCompletionAsync (completionContext, completionChar, token);
		}
        public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength)
        {
            if (mCompletionEnabled && completionContext.TriggerOffset != mCacheTriggerOffset)
            {
                return GetCompletionList (completionContext);
            }

            return null;
        }
Example #18
0
        public override Task <ParameterHintingResult> ParameterCompletionCommand(MonoDevelop.Ide.CodeCompletion.CodeCompletionContext completionContext)
        {
            var projectedExtension = GetExtensionAt(completionContext.TriggerOffset);

            if (projectedExtension == null)
            {
                return(null);
            }
            return(projectedExtension.ParameterCompletionCommand(ConvertContext(completionContext)));
        }
Example #19
0
        public override Task <ParameterHintingResult> HandleParameterCompletionAsync(MonoDevelop.Ide.CodeCompletion.CodeCompletionContext completionContext, char completionChar, System.Threading.CancellationToken token)
        {
            var projectedExtension = GetExtensionAt(completionContext.TriggerOffset);

            if (projectedExtension == null)
            {
                return(Task.FromResult <ParameterHintingResult> (null));
            }
            return(projectedExtension.HandleParameterCompletionAsync(ConvertContext(completionContext), completionChar, token));
        }
        public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char triggerChar, ref int triggerWordLength)
        {
            updater.FinishUpdate();

            if (!EnableCodeCompletion)
                return null;
            if (!EnableAutoCodeCompletion && char.IsLetter(triggerChar))
                return null;

            if (char.IsLetterOrDigit(triggerChar) || triggerChar == '_')
            {
                if (completionContext.TriggerOffset > 1){
                    var prevChar = document.Editor.GetCharAt(completionContext.TriggerOffset - 2);
                    if(char.IsLetterOrDigit(prevChar) || prevChar == '"' || prevChar == '#') // Don't trigger if we're already typing an identifier or if we're typing a string suffix (kinda hacky though)
                        return null;
                }
            }
            else if (!(triggerChar==' ' ||
                triggerChar == '@' ||
                triggerChar == '(' ||
                triggerChar == '.' ||
                triggerChar == '\0'))
                return null;

            triggerWordLength = (char.IsLetter(triggerChar) || triggerChar=='_' || triggerChar=='@') ? 1 : 0;

            // Require a parsed D source

            var dom = base.Document.ParsedDocument as ParsedDModule;
            if (dom == null || dom.DDom == null)
                return null;

            var l = new CompletionDataList();

            if (D_Parser.Misc.CompletionOptions.Instance.EnableSuggestionMode)
            {
                l.AddKeyHandler(new SuggestionKeyHandler());
                l.AutoCompleteUniqueMatch = false;
                l.AutoCompleteEmptyMatch = false;
                l.AutoSelect = true;
            }
            else
                l.AddKeyHandler(new DoubleUnderScoreWorkaroundHandler());

            lock(dom.DDom)
                DCodeCompletionSupport.BuildCompletionData(
                    Document,
                    dom.DDom,
                    completionContext,
                    l,
                    triggerChar);

            return l.Count != 0 ? l : null;
        }
 public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength)
 {
     var completionDataList = new CompletionDataList();
     sectionCompletion.FillCompletionList(completionDataList, completionContext, completionChar, ref triggerWordLength);
     directives.FillCompletionList(completionDataList, completionContext, completionChar, ref triggerWordLength);
     if(completionDataList.Count == 0)
     {
         return null;
     }
     return completionDataList;
 }
		public override ICompletionDataProvider CodeCompletionCommand (CodeCompletionContext completionContext)
		{
			int pos = completionContext.TriggerOffset;
			string txt = Editor.GetText (pos - 1, pos);
			int triggerWordLength = 0;
			ICompletionDataProvider cp = null;
			if (txt.Length > 0)
				cp = HandleCodeCompletion ((CodeCompletionContext) completionContext, true, ref triggerWordLength);
			
			return cp;
		}
		public static CompletionDataList CreateProvider (string text, string extension, bool isCtrlSpace)
		{
			string parsedText;
			string editorText;
			int cursorPosition = text.IndexOf ('$');
			int endPos = text.IndexOf ('$', cursorPosition + 1);
			if (endPos == -1)
				parsedText = editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1);
			else {
				parsedText = text.Substring (0, cursorPosition) + new string (' ', endPos - cursorPosition) + text.Substring (endPos + 1);
				editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring (endPos + 1);
				cursorPosition = endPos - 1; 
			}
			var tww = new MonoDevelop.CSharpBinding.Tests.TestWorkbenchWindow ();
			var sev = new MonoDevelop.CSharpBinding.Tests.TestViewContent ();
			var project = new AspNetAppProject ("C#");
			project.FileName = UnitTests.TestBase.GetTempFile (".csproj");
			
			string file = UnitTests.TestBase.GetTempFile (extension);
			project.AddFile (file);
			
			ProjectDomService.Load (project);
			ProjectDom dom = ProjectDomService.GetProjectDom (project);
			dom.ForceUpdate (true);
			ProjectDomService.Parse (project, file, delegate { return parsedText; });
			ProjectDomService.Parse (project, file, delegate { return parsedText; });
			
			sev.Project = project;
			sev.ContentName = file;
			sev.Text = editorText;
			sev.CursorPosition = cursorPosition;
			tww.ViewContent = sev;
			var doc = new MonoDevelop.Ide.Gui.Document (tww);
			doc.ParsedDocument = new MonoDevelop.AspNet.Parser.AspNetParser ().Parse (null, sev.ContentName, parsedText);
			foreach (var e in doc.ParsedDocument.Errors)
				Console.WriteLine (e);
			
			var textEditorCompletion = new MonoDevelop.AspNet.Gui.AspNetEditorExtension ();
			Initialize (textEditorCompletion, doc);
			
			int triggerWordLength = 1;
			CodeCompletionContext ctx = new CodeCompletionContext ();
			ctx.TriggerOffset = sev.CursorPosition;
			int line, column;
			sev.GetLineColumnFromPosition (sev.CursorPosition, out line, out column);
			ctx.TriggerLine = line;
			ctx.TriggerLineOffset = column - 1;
			
			if (isCtrlSpace)
				return textEditorCompletion.CodeCompletionCommand (ctx) as CompletionDataList;
			else
				return textEditorCompletion.HandleCodeCompletion (ctx, editorText[cursorPosition - 1] , ref triggerWordLength) as CompletionDataList;
		}
		public void ShowCompletion (ICompletionDataList completionList)
		{
			currentCompletionContext = CompletionWidget.CreateCodeCompletionContext (Document.Editor.Caret.Offset);
			int cpos, wlen;
			if (!GetCompletionCommandOffset (out cpos, out wlen)) {
				cpos = Document.Editor.Caret.Offset;
				wlen = 0;
			}
			currentCompletionContext.TriggerOffset = cpos;
			currentCompletionContext.TriggerWordLength = wlen;
			
			CompletionWindowManager.ShowWindow ('\0', completionList, CompletionWidget, currentCompletionContext, OnCompletionWindowClosed);
		}
		static CodeCompletionContext GetCodeCompletionContext (bool cSharpContext, TestViewContent sev, UnderlyingDocument underlyingDocument)
		{
			var ctx = new CodeCompletionContext ();
			if (!cSharpContext)
				ctx.TriggerOffset = sev.CursorPosition;
			else
				ctx.TriggerOffset = underlyingDocument.Editor.CaretOffset;

			int line, column;
			sev.GetLineColumnFromPosition (ctx.TriggerOffset, out line, out column);
			ctx.TriggerLine = line;
			ctx.TriggerLineOffset = column - 1;

			return ctx;
		}
		CSharpCompletionTextEditorExtension CreateCompletion (MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context, UnderlyingDocumentInfo docInfo,
			out CodeCompletionContext codeCompletionContext)
		{
			var documentLocation = docInfo.UnderlyingDocument.Editor.OffsetToLocation (docInfo.CaretPosition);

			codeCompletionContext = new CodeCompletionContext () {
				TriggerOffset = docInfo.CaretPosition,
				TriggerLine = documentLocation.Line,
				TriggerLineOffset = documentLocation.Column - 1
			};

			return new CSharpCompletionTextEditorExtension (docInfo.UnderlyingDocument) {
				CompletionWidget = CreateCompletionWidget (editor, context, docInfo)
			};
		}
		protected override ICompletionDataList HandleCodeCompletion (CodeCompletionContext completionContext, bool forced, ref int triggerWordLength)
		{
			if ((Tracker.Engine.CurrentState is XmlDoubleQuotedAttributeValueState
			    || Tracker.Engine.CurrentState is XmlSingleQuotedAttributeValueState))
			{
				// completionChar may be a space even if the current char isn't, when ctrl-space is fired t
				int currentPosition = Editor.CursorPosition;
				if (currentPosition > 0) {
					string s = Editor.GetText (currentPosition - Tracker.Engine.CurrentStateLength, currentPosition);
					if (s.EndsWith ("/"))
						return GetPathCompletion (s);
				}
			}
			return base.HandleCodeCompletion (completionContext, forced, ref triggerWordLength);
		}
Example #28
0
        public static DParameterDataProvider Create(Document doc, DModule SyntaxTree, CodeCompletionContext ctx)
        {
            var caretLocation = new CodeLocation (ctx.TriggerLineOffset, ctx.TriggerLine);

            var edData = DResolverWrapper.CreateEditorData(doc);

            edData.CaretLocation=caretLocation;
            edData.CaretOffset=ctx.TriggerOffset;

            var argsResult = ParameterInsightResolution.ResolveArgumentContext (edData);

            if (argsResult == null || argsResult.ResolvedTypesOrMethods == null || argsResult.ResolvedTypesOrMethods.Length < 1)
                return null;

            return new DParameterDataProvider(doc, argsResult, ctx.TriggerOffset);
        }
		public override ICompletionDataList CodeCompletionCommand (CodeCompletionContext completionContext)
		{
			//MonoDevelop.Ide.MessageService.ShowError ("CodeCompletionCommand");
			// This default implementation of CodeCompletionCommand calls HandleCodeCompletion providing
			// the char at the cursor position. If it returns a provider, just return it.
			
			int pos = completionContext.TriggerOffset;
			if (pos > 0) {
				char ch = Editor.GetCharAt (pos - 1);
				int triggerWordLength = completionContext.TriggerWordLength;
				ICompletionDataList completionList = HandleCodeCompletion (completionContext, ch, ref triggerWordLength);
				if (completionList != null)
					return completionList;
			}
			return null;
		}
		internal static IParameterDataProvider CreateProvider (string text)
		{
			string parsedText;
			string editorText;
			int cursorPosition = text.IndexOf ('$');
			int endPos = text.IndexOf ('$', cursorPosition + 1);
			if (endPos == -1)
				parsedText = editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1);
			else {
				parsedText = text.Substring (0, cursorPosition) + new string (' ', endPos - cursorPosition) + text.Substring (endPos + 1);
				editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring (endPos + 1);
				cursorPosition = endPos - 1; 
			}
			
			TestWorkbenchWindow tww = new TestWorkbenchWindow ();
			TestViewContent sev = new TestViewContent ();
			DotNetProject project = new DotNetAssemblyProject ("C#");
			project.FileName = GetTempFile (".csproj");
			
			string file = GetTempFile (".cs");
			project.AddFile (file);
			
			ProjectDomService.Load (project);
//			ProjectDom dom = ProjectDomService.GetProjectDom (project);
			ProjectDomService.Parse (project, file, delegate { return parsedText; });
			ProjectDomService.Parse (project, file, delegate { return parsedText; });
			
			sev.Project = project;
			sev.ContentName = file;
			sev.Text = editorText;
			sev.CursorPosition = cursorPosition;
			tww.ViewContent = sev;
			Document doc = new Document (tww);
			doc.ParsedDocument = new NRefactoryParser ().Parse (null, sev.ContentName, parsedText);
			CSharpTextEditorCompletion textEditorCompletion = new CSharpTextEditorCompletion (doc);
			
			CodeCompletionContext ctx = new CodeCompletionContext ();
			ctx.TriggerOffset = sev.CursorPosition;
			int line, column;
			sev.GetLineColumnFromPosition (sev.CursorPosition, out line, out column);
			ctx.TriggerLine = line;
			ctx.TriggerLineOffset = column - 1;
			
			IParameterDataProvider result = textEditorCompletion.HandleParameterCompletion (ctx, editorText[cursorPosition - 1]);
			ProjectDomService.Unload (project);
			return result;
		}
		void PopupCompletion ()
		{
			Gtk.Application.Invoke (delegate {
				char c = (char) Gdk.Keyval.ToUnicode (keyValue);
				if (currentCompletionData == null && IsCompletionChar (c)) {
					string expr = Buffer.GetText (TokenBegin, Cursor, false);
					currentCompletionData = GetCompletionData (expr);
					if (currentCompletionData != null) {
						DebugCompletionDataList dataList = new DebugCompletionDataList (currentCompletionData);
						ctx = ((ICompletionWidget) this).CreateCodeCompletionContext (expr.Length - currentCompletionData.ExpressionLength);
						CompletionWindowManager.ShowWindow (null, c, dataList, this, ctx);
					} else {
						currentCompletionData = null;
					}
				}
			});
		}
 public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char completionChar)
 {
     switch (completionChar) {
     case '(':
     case ' ':
     case '=':
     case '\t':
     case '\n':
     case '.':
         var compUnit = Document.ParsedDocument.CompilationUnit as PythonCompilationUnit;
         if (compUnit != null)
             return GenerateCompletionData (completionContext, compUnit.Module, Editor, completionChar);
         return null;
     default:
         return null;
     }
 }
        public static bool ShowWindow(char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate)
        {
            try {
                if (wnd == null)
                {
                    wnd = new CompletionListWindow();
                    wnd.WordCompleted += HandleWndWordCompleted;
                }
                try {
                    if (!wnd.ShowListWindow(firstChar, list, completionWidget, completionContext, closedDelegate))
                    {
                        if (list is IDisposable)
                        {
                            ((IDisposable)list).Dispose();
                        }
                        DestroyWindow();
                        return(false);
                    }

                    if (ForceSuggestionMode)
                    {
                        wnd.AutoSelect = false;
                    }

                    OnWindowShown(EventArgs.Empty);
                    return(true);
                } catch (Exception ex) {
                    LoggingService.LogError(ex.ToString());
                    return(false);
                }
            } finally {
                ParameterInformationWindowManager.UpdateWindow(completionWidget);
            }
        }
        internal static void ShowWindow(CompletionTextEditorExtension ext, ICompletionWidget widget, CodeCompletionContext ctx, ParameterHintingResult provider)
        {
            if (provider.Count == 0)
            {
                return;
            }

            // There can be several method parameter lists open at the same time, so
            // they have to be queued. The last one of queue is the one being shown
            // in the information window.

            MethodData md = new MethodData();

            md.MethodProvider    = provider;
            md.CurrentOverload   = 0;
            md.CompletionContext = ctx;
            currentMethodGroup   = md;
            UpdateOverload(ext, widget, default(CancellationToken));
            UpdateWindow(ext, widget);
        }
        public static void ShowWindow(CompletionTextEditorExtension ext, ICompletionWidget widget, CodeCompletionContext ctx, ParameterDataProvider provider)
        {
            if (provider.Count == 0)
            {
                return;
            }

            // There can be several method parameter lists open at the same time, so
            // they have to be queued. The last one of queue is the one being shown
            // in the information window.

            MethodData md = new MethodData();

            md.MethodProvider    = provider;
            md.CurrentOverload   = 0;
            md.CompletionContext = ctx;
            methods.Add(md);
            UpdateOverload(ext, widget);
            UpdateWindow(ext, widget);
        }
 internal void InitializeListWindow(ICompletionWidget completionWidget, CodeCompletionContext completionContext)
 {
     window.InitializeListWindow(completionWidget, completionContext);
 }
 internal bool ShowListWindow(char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
 {
     return(window.ShowListWindow(firstChar, list, completionWidget, completionContext));
 }
 internal bool ShowListWindow(ICompletionDataList list, CodeCompletionContext completionContext)
 {
     return(window.ShowListWindow(list, completionContext));
 }
Example #39
0
 internal bool ShowListWindow(char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
 {
     controller.InitializeSession(completionWidget, completionContext);
     return(ShowListWindow(list, completionContext));
 }
 // ext may be null, but then parameter completion don't work
 internal static bool ShowWindow(CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
 {
     PrepareShowWindow(ext, firstChar, completionWidget, completionContext);
     return(ShowWindow(list, completionContext));
 }
        // ext may be null, but then parameter completion don't work
        internal static void PrepareShowWindow(CompletionTextEditorExtension ext, char firstChar, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
        {
            isShowing = true;

            if (wnd == null)
            {
                wnd = new CompletionListWindow();
                wnd.WordCompleted += HandleWndWordCompleted;
            }
            if (ext != null)
            {
                var widget = ext.Editor.GetNativeWidget <Gtk.Widget> ();
                wnd.TransientFor = widget?.Parent?.Toplevel as Gtk.Window;
            }
            else
            {
                var widget = completionWidget as Gtk.Widget;
                if (widget != null)
                {
                    var window = widget.Toplevel as Gtk.Window;
                    if (window != null)
                    {
                        wnd.TransientFor = window;
                    }
                }
            }
            wnd.Extension = ext;

            wnd.InitializeListWindow(completionWidget, completionContext);
        }
Example #42
0
        public override MonoDevelop.Ide.CodeCompletion.ICompletionDataList ShowCodeTemplatesCommand(MonoDevelop.Ide.CodeCompletion.CodeCompletionContext completionContext)
        {
            var projectedExtension = GetExtensionAt(completionContext.TriggerOffset);

            if (projectedExtension == null)
            {
                return(null);
            }
            return(projectedExtension.ShowCodeTemplatesCommand(ConvertContext(completionContext)));
        }
        // ext may be null, but then parameter completion don't work
        public static bool ShowWindow(CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
        {
            try {
                if (ext != null)
                {
                    int inserted = ext.document.Editor.EnsureCaretIsNotVirtual();
                    if (inserted > 0)
                    {
                        completionContext.TriggerOffset = ext.document.Editor.Caret.Offset;
                    }
                }
                if (wnd == null)
                {
                    wnd = new CompletionListWindow();
                    wnd.WordCompleted += HandleWndWordCompleted;
                }
                if (ext != null)
                {
                    wnd.TransientFor = ext.document.Editor.Parent.Toplevel as Gtk.Window;
                }
                wnd.Extension = ext;
                try {
                    if (!wnd.ShowListWindow(firstChar, list, completionWidget, completionContext))
                    {
                        if (list is IDisposable)
                        {
                            ((IDisposable)list).Dispose();
                        }
                        HideWindow();
                        return(false);
                    }

                    if (ForceSuggestionMode)
                    {
                        wnd.AutoSelect = false;
                    }
                    wnd.Show();
                    DesktopService.RemoveWindowShadow(wnd);
                    OnWindowShown(EventArgs.Empty);
                    return(true);
                } catch (Exception ex) {
                    LoggingService.LogError(ex.ToString());
                    return(false);
                }
            } finally {
                ParameterInformationWindowManager.UpdateWindow(ext, completionWidget);
            }
        }
Example #44
0
 internal void InitializeListWindow(ICompletionWidget completionWidget, CodeCompletionContext completionContext)
 {
     controller.InitializeSession(completionWidget, completionContext);
 }
Example #45
0
        public override System.Threading.Tasks.Task <MonoDevelop.Ide.CodeCompletion.ICompletionDataList> HandleCodeCompletionAsync(MonoDevelop.Ide.CodeCompletion.CodeCompletionContext completionContext, char completionChar, System.Threading.CancellationToken token)
        {
            var projectedExtension = GetExtensionAt(completionContext.TriggerOffset);

            if (projectedExtension == null)
            {
                return(null);
            }

            return(projectedExtension.HandleCodeCompletionAsync(ConvertContext(completionContext), completionChar, token));
        }
        internal bool ShowListWindow(ICompletionDataList list, CodeCompletionContext completionContext)
        {
            if (list == null)
            {
                throw new ArgumentNullException("list");
            }

            CodeCompletionContext = completionContext;
            CompletionDataList    = list;
            ResetState();

            mutableList             = completionDataList as IMutableCompletionDataList;
            PreviewCompletionString = completionDataList.CompletionSelectionMode == CompletionSelectionMode.OwnTextField;

            if (mutableList != null)
            {
                mutableList.Changing += OnCompletionDataChanging;
                mutableList.Changed  += OnCompletionDataChanged;

                if (mutableList.IsChanging)
                {
                    OnCompletionDataChanging(null, null);
                }
            }

            if (FillList())
            {
                AutoSelect                         = list.AutoSelect;
                AutoCompleteEmptyMatch             = list.AutoCompleteEmptyMatch;
                AutoCompleteEmptyMatchOnCurlyBrace = list.AutoCompleteEmptyMatchOnCurlyBrace;
                CloseOnSquareBrackets              = list.CloseOnSquareBrackets;
                // makes control-space in midle of words to work
                string text = CompletionWidget.GetCompletionText(CodeCompletionContext);
                DefaultCompletionString = completionDataList.DefaultCompletionString ?? "";
                if (text.Length == 0)
                {
                    initialWordLength = 0;
                    //completionWidget.SelectedLength;
                    StartOffset = completionContext.TriggerOffset;
                    UpdateWordSelection();
                    ResetSizes();
                    ShowAll();
                    UpdateWordSelection();
                    UpdateDeclarationView();
                    //if there is only one matching result we take it by default
                    if (completionDataList.AutoCompleteUniqueMatch && IsUniqueMatch && !IsChanging)
                    {
                        CompleteWord();
                        CompletionWindowManager.HideWindow();
                        return(false);
                    }
                    return(true);
                }

                initialWordLength   = CompletionWidget.SelectedLength > 0 ? 0 : text.Length;
                StartOffset         = CompletionWidget.CaretOffset - initialWordLength;
                HideWhenWordDeleted = initialWordLength != 0;
                ResetSizes();
                UpdateWordSelection();
                //if there is only one matching result we take it by default
                if (completionDataList.AutoCompleteUniqueMatch && IsUniqueMatch && !IsChanging)
                {
                    CompleteWord();
                    CompletionWindowManager.HideWindow();
                    return(false);
                }
                ShowAll();
                UpdateDeclarationView();
                return(true);
            }
            CompletionWindowManager.HideWindow();
            return(false);
        }
Example #47
0
 public CodeCompletionContextEventArgs(ICompletionWidget widget, CodeCompletionContext codeCompletionContext, string completedWord)
 {
     this.Widget = widget;
     this.CodeCompletionContext = codeCompletionContext;
     this.CompletedWord         = completedWord;
 }
Example #48
0
        internal bool ShowListWindow(char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate)
        {
            if (mutableList != null)
            {
                mutableList.Changing -= OnCompletionDataChanging;
                mutableList.Changed  -= OnCompletionDataChanged;
                HideFooter();
            }
            //initialWordLength = 0;
            this.completionDataList             = list;
            this.CompleteWithSpaceOrPunctuation = MonoDevelop.Core.PropertyService.Get("CompleteWithSpaceOrPunctuation", true);

            this.CodeCompletionContext = completionContext;
            this.closedDelegate        = closedDelegate;
            mutableList = completionDataList as IMutableCompletionDataList;
            List.PreviewCompletionString = completionDataList.CompletionSelectionMode == CompletionSelectionMode.OwnTextField;

            if (mutableList != null)
            {
                mutableList.Changing += OnCompletionDataChanging;
                mutableList.Changed  += OnCompletionDataChanged;

                if (mutableList.IsChanging)
                {
                    OnCompletionDataChanging(null, null);
                }
            }

            this.CompletionWidget = completionWidget;

            if (FillList())
            {
// not neccessarry, because list window is not reused anymore:
//				Reset (true);
                this.AutoSelect             = list.AutoSelect;
                this.AutoCompleteEmptyMatch = list.AutoCompleteEmptyMatch;
                // makes control-space in midle of words to work
                string text = completionWidget.GetCompletionText(completionContext);
                DefaultCompletionString = completionDataList.DefaultCompletionString ?? "";
                if (text.Length == 0)
                {
                    UpdateWordSelection();
                    initialWordLength = 0;                    //completionWidget.SelectedLength;
                    ResetSizes();
                    ShowAll();
                    UpdateWordSelection();

                    //if there is only one matching result we take it by default
                    if (completionDataList.AutoCompleteUniqueMatch && IsUniqueMatch && !IsChanging)
                    {
                        CompleteWord();
                        CompletionWindowManager.HideWindow();
                    }
                    return(true);
                }

                initialWordLength = text.Length /*+ completionWidget.SelectedLength*/;
                PartialWord       = text;
                UpdateWordSelection();

                //if there is only one matching result we take it by default
                if (completionDataList.AutoCompleteUniqueMatch && IsUniqueMatch && !IsChanging)
                {
                    CompleteWord();
                    CompletionWindowManager.HideWindow();
                }
                else
                {
                    ResetSizes();
                    ShowAll();
                }
                return(true);
            }
            CompletionWindowManager.HideWindow();

            return(false);
        }