static string GetCurrentWordForMethods(CompletionListWindow window, MonoDevelop.Ide.Editor.Extension.KeyDescriptor descriptor) { int partialWordLength = window.PartialWord != null ? window.PartialWord.Length : 0; int replaceLength; if (descriptor.SpecialKey == SpecialKey.Return || descriptor.SpecialKey == SpecialKey.Tab) { replaceLength = window.CodeCompletionContext.TriggerWordLength + partialWordLength - window.InitialWordLength; } else { replaceLength = partialWordLength; } int endOffset = Math.Min(window.StartOffset + replaceLength, window.CompletionWidget.TextLength); if (descriptor.KeyChar == '(' && DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket) { endOffset++; if (DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket) { endOffset++; } } var result = window.CompletionWidget.GetText(window.StartOffset, endOffset); return(result); }
public override bool KeyPress(KeyDescriptor descriptor) { // generic mode escape handler if ( (descriptor.ModifierKeys == 0 && descriptor.SpecialKey == SpecialKey.Escape) || (descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == '[') || (descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == 'c')) { _currentMode.Deactivate(); _currentMode = _requestedMode = _normalMode; _currentMode.Activate(); return false; } var pass = _currentMode.KeyPress (descriptor); var newMode = _currentMode.RequestedMode; if (newMode == ViMode.Normal) _requestedMode = _normalMode; else if (newMode == ViMode.Insert) _requestedMode = _insertMode; else if (newMode == ViMode.Visual) _requestedMode = _visualMode; if (_requestedMode != _currentMode) { _currentMode.RequestedMode = ViMode.None; _currentMode.Deactivate(); _requestedMode.Activate(); _currentMode = _requestedMode; } return pass && base.KeyPress(descriptor); }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { if (methods.Count == 0) return false; MethodData cmd = methods [methods.Count - 1]; if (descriptor.SpecialKey == SpecialKey.Down) { if (cmd.MethodProvider.Count <= 1) return false; if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1) cmd.CurrentOverload ++; else cmd.CurrentOverload = 0; window.ChangeOverload (); UpdateWindow (ext, widget); return true; } else if (descriptor.SpecialKey == SpecialKey.Up) { if (cmd.MethodProvider.Count <= 1) return false; if (cmd.CurrentOverload > 0) cmd.CurrentOverload --; else cmd.CurrentOverload = cmd.MethodProvider.Count - 1; window.ChangeOverload (); UpdateWindow (ext, widget); return true; } else if (descriptor.SpecialKey == SpecialKey.Escape) { HideWindow (ext, widget); return true; } return false; }
public override bool KeyPress (KeyDescriptor descriptor) { if (descriptor.KeyChar != '/') return base.KeyPress (descriptor); var line = Editor.GetLine (Editor.CaretLine); string text = Editor.GetTextAt (line.Offset, line.Length); if (!text.EndsWith ("//", StringComparison.Ordinal)) return base.KeyPress (descriptor); // check if there is doc comment above or below. var l = line.PreviousLine; while (l != null && l.Length == 0) l = l.PreviousLine; if (l != null && Editor.GetTextAt (l).TrimStart ().StartsWith ("///", StringComparison.Ordinal)) return base.KeyPress (descriptor); l = line.NextLine; while (l != null && l.Length == 0) l = l.NextLine; if (l != null && Editor.GetTextAt (l).TrimStart ().StartsWith ("///", StringComparison.Ordinal)) return base.KeyPress (descriptor); var memberTask = GetMemberToDocument (); if (!memberTask.Wait (250) || memberTask.Result == null) return base.KeyPress (descriptor); var member = memberTask.Result; string documentation = GenerateDocumentation (member, Editor.GetLineIndent (line)); if (string.IsNullOrEmpty (documentation)) return base.KeyPress (descriptor); string documentationEmpty = GenerateEmptyDocumentation (member, Editor.GetLineIndent (line)); int offset = Editor.CaretOffset; int insertedLength; // Insert key (3rd undo step) Editor.InsertText (offset, "/"); using (var undo = Editor.OpenUndoGroup ()) { documentationEmpty = Editor.FormatString (offset, documentationEmpty); insertedLength = documentationEmpty.Length; Editor.ReplaceText (offset, 1, documentationEmpty); // important to set the caret position here for the undo step Editor.CaretOffset = offset + insertedLength; } using (var undo = Editor.OpenUndoGroup ()) { documentation = Editor.FormatString (offset, documentation); Editor.ReplaceText (offset, insertedLength, documentation); insertedLength = documentation.Length; if (SelectSummary (offset, insertedLength, documentation) == false) Editor.CaretOffset = offset + insertedLength; } return false; }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { var editor = factory.Ext.Editor; var offset = window.CodeCompletionContext.TriggerOffset; using (var undo = editor.OpenUndoGroup ()) { base.InsertCompletionText (window, ref ka, descriptor); var span = nodeToCast.Span; var type = SafeMinimalDisplayString (targetType, semanticModel, nodeToCast.SpanStart, Ambience.LabelFormat); editor.ReplaceText (span.Start, span.Length, "((" + type + ")" + nodeToCast + ")"); } }
public override bool KeyPress (KeyDescriptor descriptor) { var result = base.KeyPress (descriptor); if (DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket && !Editor.IsSomethingSelected) { var handler = allHandlers.FirstOrDefault(h => h.CanHandle (Editor)); if (handler != null && handler.Handle (Editor, DocumentContext, descriptor)) return false; } return result; }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { var buf = window.CompletionWidget; if (buf != null) { //completion context gets nulled from window as soon as we alter the buffer var codeCompletionContext = window.CodeCompletionContext; buf.Replace (buf.CaretOffset, 0, element); // Move caret into the middle of the tags buf.CaretOffset = codeCompletionContext.TriggerOffset + cursorOffset; } }
public override bool KeyPress (KeyDescriptor descriptor) { var result = base.KeyPress (descriptor); if (descriptor.SpecialKey == SpecialKey.Return) { if (Editor.Options.IndentStyle == MonoDevelop.Ide.Editor.IndentStyle.Virtual) { if (Editor.GetLine (Editor.CaretLine).Length == 0) Editor.CaretColumn = Editor.GetVirtualIndentationColumn (Editor.CaretLine); } else { DoReSmartIndent (); } } return result; }
// Called when a key is pressed in the editor. // Returns false if the key press has to continue normal processing. internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { if (currentMethodGroup == null) return false; if (descriptor.SpecialKey == SpecialKey.Down) { return OverloadDown (ext, widget); } else if (descriptor.SpecialKey == SpecialKey.Up) { return OverloadUp (ext, widget); } else if (descriptor.SpecialKey == SpecialKey.Escape) { HideWindow (ext, widget); return true; } return false; }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { //insert the method name var buf = window.CompletionWidget; if (buf != null) { buf.Replace (window.CodeCompletionContext.TriggerOffset, buf.CaretOffset - window.CodeCompletionContext.TriggerOffset, methodInfo.Name); } //generate the codebehind method // TODO: Roslyn port. // if (codeBehindClassLocation != null && project != null) // BindingService.AddMemberToClass (project, codeBehindClass, codeBehindClassLocation, methodInfo, false); // else // BindingService.AddMemberToClass (project, codeBehindClass, codeBehindClass.Locations.First (), methodInfo, false); }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { var buf = window.CompletionWidget; if (buf != null) { int deleteStartOffset = window.CodeCompletionContext.TriggerOffset; if (text.StartsWith (docTypeStart)) { int start = window.CodeCompletionContext.TriggerOffset - docTypeStart.Length; if (start >= 0) { string readback = buf.GetText (start, window.CodeCompletionContext.TriggerOffset); if (string.Compare (readback, docTypeStart, StringComparison.OrdinalIgnoreCase) == 0) deleteStartOffset -= docTypeStart.Length; } } buf.Replace (deleteStartOffset, buf.CaretOffset - deleteStartOffset, text); } }
public override bool Handle (TextEditor editor, DocumentContext ctx, KeyDescriptor descriptor) { char closingBrace; if (!IsSupportedOpeningBrace (descriptor.KeyChar, out closingBrace) || !CheckCodeContext (editor, ctx, editor.CaretOffset - 1, descriptor.KeyChar, default (CancellationToken))) return false; var session = CreateEditorSession (editor, ctx, editor.CaretOffset, descriptor.KeyChar, default (CancellationToken)); session.SetEditor (editor); if (session == null | !((ICheckPointEditSession)session).CheckOpeningPoint (editor, ctx, default (CancellationToken))) return false; using (var undo = editor.OpenUndoGroup ()) { editor.EnsureCaretIsNotVirtual (); editor.InsertAtCaret (closingBrace.ToString ()); editor.CaretOffset--; editor.StartSession (session); } return true; }
public static string GetCurrentWord(CompletionListWindow window, MonoDevelop.Ide.Editor.Extension.KeyDescriptor descriptor) { int partialWordLength = window.PartialWord != null ? window.PartialWord.Length : 0; int replaceLength; if (descriptor.SpecialKey == SpecialKey.Return || descriptor.SpecialKey == SpecialKey.Tab) { replaceLength = window.CodeCompletionContext.TriggerWordLength + partialWordLength - window.InitialWordLength; } else { replaceLength = partialWordLength; } int endOffset = Math.Min(window.StartOffset + replaceLength, window.CompletionWidget.TextLength); var result = window.CompletionWidget.GetText(window.StartOffset, endOffset); return(result); }
public override bool KeyPress(KeyDescriptor descriptor) { // generic mode escape handler if ( (descriptor.ModifierKeys == 0 && descriptor.SpecialKey == SpecialKey.Escape) || (descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == '[') || (descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == 'c')) { CurrentMode.InternalDeactivate(); CurrentMode = _requestedMode = _normalMode; CurrentMode.InternalActivate(); return false; } var pass = CurrentMode.KeyPress (descriptor); var newMode = CurrentMode.RequestedMode; if (newMode == Mode.Normal) _requestedMode = _normalMode; else if (newMode == Mode.Insert) _requestedMode = _insertMode; else if (newMode == Mode.Visual) { _visualMode.Select = SelectMode.Normal; _requestedMode = _visualMode; } else if (newMode == Mode.VisualLine) { _visualMode.Select = SelectMode.Line; _requestedMode = _visualMode; } else if (newMode == Mode.Replace) _requestedMode = _replaceMode; if (_requestedMode != CurrentMode) { CurrentMode.RequestedMode = Mode.None; CurrentMode.InternalDeactivate(); _requestedMode.InternalActivate(); CurrentMode = _requestedMode; } return pass && base.KeyPress(descriptor); }
public override bool KeyPress(KeyDescriptor descriptor) { var result = base.KeyPress(descriptor); // if the AutoInsertMatchingBracket option was changed since initialization if (DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket != isEnabled) { SetEnabled(DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket); } if (isEnabled && !Editor.IsSomethingSelected) { foreach (var handler in handlers) { if (handler.CanHandle(Editor)) { handler.Handle(Editor, DocumentContext, descriptor); break; } } } return(result); }
public override bool KeyPress (KeyDescriptor descriptor) { if (!IsActiveExtension()) return Next == null || Next.KeyPress (descriptor); return completionTextEditorExtension.KeyPress (descriptor); }
public virtual async void RunParameterCompletionCommand() { if (Editor.SelectionMode == SelectionMode.Block || CompletionWidget == null) { return; } ParameterHintingResult cp = null; int cpos = Editor.CaretOffset; CodeCompletionContext ctx = CompletionWidget.CreateCodeCompletionContext(cpos); cp = await ParameterCompletionCommand(ctx); if (cp != null) { ParameterInformationWindowManager.ShowWindow(this, CompletionWidget, ctx, cp); ParameterInformationWindowManager.PostProcessKeyEvent(this, CompletionWidget, KeyDescriptor.FromGtk(Gdk.Key.F, 'f', Gdk.ModifierType.None)); } }
public override bool KeyPress (KeyDescriptor descriptor) { var task = ctx.GetPartialProjectionsAsync (); if (task != null) projections = task.Result; var projectedExtension = GetCurrentExtension(); if (projectedExtension != null) { return projectedExtension.KeyPress (descriptor); } return base.KeyPress (descriptor); }
public override bool KeyPress (KeyDescriptor descriptor) { if (Editor.Options.IndentStyle == IndentStyle.Smart) { var newLine = Editor.CaretLine + 1; var ret = base.KeyPress (descriptor); if (descriptor.SpecialKey == SpecialKey.Return && Editor.CaretLine == newLine) { string indent = GetLineIndent (newLine); var oldIndent = Editor.GetLineIndent (newLine); var seg = Editor.GetLine (newLine); if (oldIndent != indent) { using (var undo = Editor.OpenUndoGroup ()) { Editor.ReplaceText (seg.Offset, oldIndent.Length, indent); } } } return ret; } return base.KeyPress (descriptor); }
// When a key is pressed, and before the key is processed by the editor, this method will be invoked. // Return true if the key press should be processed by the editor. public override bool KeyPress (KeyDescriptor descriptor) { bool res; if (CurrentCompletionContext != null) { if (CompletionWindowManager.PreProcessKeyEvent (descriptor)) { CompletionWindowManager.PostProcessKeyEvent (descriptor); autoHideCompletionWindow = true; // in named parameter case leave the parameter window open. autoHideParameterWindow = descriptor.KeyChar != ':'; if (!autoHideParameterWindow && ParameterInformationWindowManager.IsWindowVisible) ParameterInformationWindowManager.PostProcessKeyEvent (this, CompletionWidget, descriptor); return false; } autoHideCompletionWindow = autoHideParameterWindow = false; } if (ParameterInformationWindowManager.IsWindowVisible) { if (ParameterInformationWindowManager.ProcessKeyEvent (this, CompletionWidget, descriptor)) return false; autoHideCompletionWindow = autoHideParameterWindow = false; } // int oldPos = Editor.CursorPosition; // int oldLen = Editor.TextLength; char deleteOrBackspaceTriggerChar = '\0'; if (descriptor.SpecialKey == SpecialKey.Delete && Editor.CaretOffset < Editor.Length) deleteOrBackspaceTriggerChar = Editor.GetCharAt (Editor.CaretOffset); if (descriptor.SpecialKey == SpecialKey.BackSpace && Editor.CaretOffset > 0) deleteOrBackspaceTriggerChar = Editor.GetCharAt (Editor.CaretOffset - 1); res = base.KeyPress (descriptor); CompletionWindowManager.PostProcessKeyEvent (descriptor); var ignoreMods = ModifierKeys.Control | ModifierKeys.Alt | ModifierKeys.Command; // Handle parameter completion if (ParameterInformationWindowManager.IsWindowVisible) { ParameterInformationWindowManager.PostProcessKeyEvent (this, CompletionWidget, descriptor); } if ((descriptor.ModifierKeys & ignoreMods) != 0) return res; // don't complete on block selection if (/*!EnableCodeCompletion ||*/ Editor.SelectionMode == MonoDevelop.Ide.Editor.SelectionMode.Block) return res; // Handle code completion if (descriptor.KeyChar != '\0' && CompletionWidget != null && !CompletionWindowManager.IsVisible) { CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; completionTokenSrc.Cancel (); completionTokenSrc = new CancellationTokenSource (); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleCodeCompletionAsync (CurrentCompletionContext, descriptor.KeyChar, token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow (this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate (object o, EventArgs a) { completionTokenSrc.Cancel (); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith (t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) return; var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext (Editor.CaretOffset - triggerWordLength); CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow (result, CurrentCompletionContext)) CurrentCompletionContext = null; } else { CompletionWindowManager.HideWindow (); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { CurrentCompletionContext = null; } catch (AggregateException) { CurrentCompletionContext = null; } } if ((descriptor.SpecialKey == SpecialKey.Delete || descriptor.SpecialKey == SpecialKey.BackSpace) && CompletionWidget != null && !CompletionWindowManager.IsVisible) { CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; int cpos, wlen; if (!GetCompletionCommandOffset (out cpos, out wlen)) { cpos = Editor.CaretOffset; wlen = 0; } CurrentCompletionContext.TriggerOffset = cpos; CurrentCompletionContext.TriggerWordLength = wlen; completionTokenSrc.Cancel (); completionTokenSrc = new CancellationTokenSource (); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleBackspaceOrDeleteCodeCompletionAsync (CurrentCompletionContext, descriptor.SpecialKey, deleteOrBackspaceTriggerChar, token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow (this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate (object o, EventArgs a) { completionTokenSrc.Cancel (); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith (t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) return; var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext (Editor.CaretOffset - triggerWordLength); CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow (result, CurrentCompletionContext)) { CurrentCompletionContext = null; } else { CompletionWindowManager.Wnd.StartOffset = CurrentCompletionContext.TriggerOffset; CompletionWindowManager.Wnd.EndOffset = Editor.CaretOffset; } } else { CompletionWindowManager.HideWindow (); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { CurrentCompletionContext = null; } catch (AggregateException) { CurrentCompletionContext = null; } } if (CompletionWidget != null) { CodeCompletionContext ctx = CompletionWidget.CurrentCodeCompletionContext; parameterHintingSrc.Cancel (); parameterHintingSrc = new CancellationTokenSource (); var token = parameterHintingSrc.Token; try { var task = HandleParameterCompletionAsync (ctx, descriptor.KeyChar, token); if (task != null) { task.ContinueWith (t => { if (!token.IsCancellationRequested && t.Result != null) ParameterInformationWindowManager.ShowWindow (this, CompletionWidget, ctx, t.Result); }, Runtime.MainTaskScheduler); } } catch (TaskCanceledException) { } catch (AggregateException) { } } /* autoHideCompletionWindow = true; autoHideParameterWindow = keyChar != ':';*/ return res; }
// public override TooltipInformation CreateTooltipInformation (bool smartWrap) // { // var sig = new SignatureMarkupCreator (ext.Editor, ext.DocumentContext, ext.Editor.CaretOffset); // sig.BreakLineAfterReturnType = smartWrap; // return sig.GetKeywordTooltip (title, null); // } public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, MonoDevelop.Ide.Editor.Extension.KeyDescriptor descriptor) { var currentWord = GetCurrentWord(window, descriptor); var text = CompletionText; if (descriptor.KeyChar == '>' && text.EndsWith(">", StringComparison.Ordinal)) { text = text.Substring(0, text.Length - 1); } if (text.StartsWith("<", StringComparison.Ordinal)) { text = text.Substring(1); } window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, currentWord, text); }
// When a key is pressed, and before the key is processed by the editor, this method will be invoked. // Return true if the key press should be processed by the editor. public override bool KeyPress(KeyDescriptor descriptor) { bool res; if (CurrentCompletionContext != null) { if (CompletionWindowManager.PreProcessKeyEvent(descriptor)) { CompletionWindowManager.PostProcessKeyEvent(descriptor); autoHideCompletionWindow = true; // in named parameter case leave the parameter window open. autoHideParameterWindow = descriptor.KeyChar != ':'; if (!autoHideParameterWindow && ParameterInformationWindowManager.IsWindowVisible) { ParameterInformationWindowManager.PostProcessKeyEvent(this, CompletionWidget, descriptor); } return(false); } autoHideCompletionWindow = autoHideParameterWindow = false; } if (ParameterInformationWindowManager.IsWindowVisible) { if (ParameterInformationWindowManager.ProcessKeyEvent(this, CompletionWidget, descriptor)) { return(false); } autoHideCompletionWindow = autoHideParameterWindow = false; } // int oldPos = Editor.CursorPosition; // int oldLen = Editor.TextLength; char deleteOrBackspaceTriggerChar = '\0'; if (descriptor.SpecialKey == SpecialKey.Delete && Editor.CaretOffset < Editor.Length) { deleteOrBackspaceTriggerChar = Editor.GetCharAt(Editor.CaretOffset); } if (descriptor.SpecialKey == SpecialKey.BackSpace && Editor.CaretOffset > 0) { deleteOrBackspaceTriggerChar = Editor.GetCharAt(Editor.CaretOffset - 1); } res = base.KeyPress(descriptor); CompletionWindowManager.PostProcessKeyEvent(descriptor); var ignoreMods = ModifierKeys.Control | ModifierKeys.Alt | ModifierKeys.Command; // Handle parameter completion if (ParameterInformationWindowManager.IsWindowVisible) { ParameterInformationWindowManager.PostProcessKeyEvent(this, CompletionWidget, descriptor); } if ((descriptor.ModifierKeys & ignoreMods) != 0) { return(res); } // don't complete on block selection if (/*!EnableCodeCompletion ||*/ Editor.SelectionMode == MonoDevelop.Ide.Editor.SelectionMode.Block) { return(res); } // Handle code completion if (descriptor.KeyChar != '\0' && CompletionWidget != null && !CompletionWindowManager.IsVisible) { CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; completionTokenSrc.Cancel(); completionTokenSrc = new CancellationTokenSource(); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleCodeCompletionAsync(CurrentCompletionContext, descriptor.KeyChar, token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow(this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate(object o, EventArgs a) { completionTokenSrc.Cancel(); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith(t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) { return; } var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext(Editor.CaretOffset - triggerWordLength); CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow(result, CurrentCompletionContext)) { CurrentCompletionContext = null; } } else { CompletionWindowManager.HideWindow(); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { CurrentCompletionContext = null; } catch (AggregateException) { CurrentCompletionContext = null; } } if ((descriptor.SpecialKey == SpecialKey.Delete || descriptor.SpecialKey == SpecialKey.BackSpace) && CompletionWidget != null && !CompletionWindowManager.IsVisible) { CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; int cpos, wlen; if (!GetCompletionCommandOffset(out cpos, out wlen)) { cpos = Editor.CaretOffset; wlen = 0; } CurrentCompletionContext.TriggerOffset = cpos; CurrentCompletionContext.TriggerWordLength = wlen; completionTokenSrc.Cancel(); completionTokenSrc = new CancellationTokenSource(); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleBackspaceOrDeleteCodeCompletionAsync(CurrentCompletionContext, descriptor.SpecialKey, deleteOrBackspaceTriggerChar, token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow(this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate(object o, EventArgs a) { completionTokenSrc.Cancel(); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith(t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) { return; } var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext(Editor.CaretOffset - triggerWordLength); CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow(result, CurrentCompletionContext)) { CurrentCompletionContext = null; } else { CompletionWindowManager.Wnd.StartOffset = CurrentCompletionContext.TriggerOffset; CompletionWindowManager.Wnd.EndOffset = Editor.CaretOffset; } } else { CompletionWindowManager.HideWindow(); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { CurrentCompletionContext = null; } catch (AggregateException) { CurrentCompletionContext = null; } } if (CompletionWidget != null) { CodeCompletionContext ctx = CompletionWidget.CurrentCodeCompletionContext; parameterHintingSrc.Cancel(); parameterHintingSrc = new CancellationTokenSource(); var token = parameterHintingSrc.Token; try { var task = HandleParameterCompletionAsync(ctx, descriptor.KeyChar, token); if (task != null) { task.ContinueWith(t => { if (!token.IsCancellationRequested && t.Result != null) { ParameterInformationWindowManager.ShowWindow(this, CompletionWidget, ctx, t.Result); } }, Runtime.MainTaskScheduler); } } catch (TaskCanceledException) { } catch (AggregateException) { } } /* autoHideCompletionWindow = true; * autoHideParameterWindow = keyChar != ':';*/ return(res); }
public override bool KeyPress (KeyDescriptor descriptor) { if (descriptor.SpecialKey == SpecialKey.Escape && DebuggingService.ExceptionCaughtMessage != null && !DebuggingService.ExceptionCaughtMessage.IsMinimized && DebuggingService.ExceptionCaughtMessage.File.CanonicalPath == new FilePath (DocumentContext.Name).CanonicalPath) { DebuggingService.ExceptionCaughtMessage.ShowMiniButton (); return true; } return base.KeyPress (descriptor); }
public override bool KeyPress (KeyDescriptor descriptor) { completionWindowWasVisible = CompletionWindowManager.IsVisible; cursorPositionBeforeKeyPress = Editor.CaretOffset; bool isSomethingSelected = Editor.IsSomethingSelected; if (descriptor.SpecialKey == SpecialKey.BackSpace && Editor.CaretOffset == lastInsertedSemicolon) { EditActions.Undo (Editor); lastInsertedSemicolon = -1; return false; } lastInsertedSemicolon = -1; if (descriptor.KeyChar == ';' && Editor.EditMode == EditMode.Edit && !DoInsertTemplate () && !isSomethingSelected && PropertyService.Get ( "SmartSemicolonPlacement", false ) && !(stateTracker.IsInsideComment || stateTracker.IsInsideString)) { bool retval = base.KeyPress (descriptor); var curLine = Editor.GetLine (Editor.CaretLine); string text = Editor.GetTextAt (curLine); if (!(text.EndsWith (";", StringComparison.Ordinal) || text.Trim ().StartsWith ("for", StringComparison.Ordinal))) { int guessedOffset; if (GuessSemicolonInsertionOffset (Editor, curLine, Editor.CaretOffset, out guessedOffset)) { using (var undo = Editor.OpenUndoGroup ()) { Editor.RemoveText (Editor.CaretOffset - 1, 1); Editor.CaretOffset = guessedOffset; lastInsertedSemicolon = Editor.CaretOffset + 1; retval = base.KeyPress (descriptor); } } } using (var undo = Editor.OpenUndoGroup ()) { if (OnTheFlyFormatting && Editor != null && Editor.EditMode == EditMode.Edit) { OnTheFlyFormatter.FormatStatmentAt (Editor, DocumentContext, Editor.CaretLocation, optionSet: optionSet); } } return retval; } if (descriptor.SpecialKey == SpecialKey.Tab && descriptor.ModifierKeys == ModifierKeys.None && !CompletionWindowManager.IsVisible) { SafeUpdateIndentEngine (Editor.CaretOffset); if (stateTracker.IsInsideStringLiteral && !Editor.IsSomethingSelected) { var lexer = new ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngineBase.MiniLexer (Editor.GetTextAt (0, Editor.CaretOffset)); lexer.Parse (); if (lexer.IsInString) { Editor.InsertAtCaret ("\\t"); return false; } } } if (descriptor.SpecialKey == SpecialKey.Tab && DefaultSourceEditorOptions.Instance.TabIsReindent && !CompletionWindowManager.IsVisible && Editor.EditMode == EditMode.Edit && !DoInsertTemplate () && !isSomethingSelected) { ReindentOnTab (); return false; } SafeUpdateIndentEngine (Editor.CaretOffset); if (!stateTracker.IsInsideOrdinaryCommentOrString) { if (descriptor.KeyChar == '@') { var retval = base.KeyPress (descriptor); int cursor = Editor.CaretOffset; if (cursor < Editor.Length && Editor.GetCharAt (cursor) == '"') ConvertNormalToVerbatimString (Editor, cursor + 1); return retval; } } //do the smart indent if (!indentationDisabled) { bool retval; //capture some of the current state int oldBufLen = Editor.Length; int oldLine = Editor.CaretLine + 1; bool reIndent = false; //pass through to the base class, which actually inserts the character //and calls HandleCodeCompletion etc to handles completion using (var undo = Editor.OpenUndoGroup ()) { DoPreInsertionSmartIndent (descriptor.SpecialKey); } wasInStringLiteral = stateTracker.IsInsideStringLiteral; bool automaticReindent; // need to be outside of an undo group - otherwise it interferes with other text editor extension // esp. the documentation insertion undo steps. retval = base.KeyPress (descriptor); //handle inserted characters if (Editor.CaretOffset <= 0 || Editor.IsSomethingSelected) return retval; lastCharInserted = TranslateKeyCharForIndenter (descriptor.SpecialKey, descriptor.KeyChar, Editor.GetCharAt (Editor.CaretOffset - 1)); if (lastCharInserted == '\0') return retval; using (var undo = Editor.OpenUndoGroup ()) { SafeUpdateIndentEngine (Editor.CaretOffset); if (descriptor.SpecialKey == SpecialKey.Return && descriptor.ModifierKeys == ModifierKeys.Control) { FixLineStart (Editor, stateTracker, Editor.CaretLine + 1); } else { if (!(oldLine == Editor.CaretLine + 1 && lastCharInserted == '\n') && (oldBufLen != Editor.Length || lastCharInserted != '\0')) { DoPostInsertionSmartIndent (lastCharInserted, out reIndent); } else { reIndent = lastCharInserted == '\n'; } } //reindent the line after the insertion, if needed //N.B. if the engine says we need to reindent, make sure that it's because a char was //inserted rather than just updating the stack due to moving around SafeUpdateIndentEngine (Editor.CaretOffset); // Automatically reindent in text link mode will cause the mode exiting, therefore we need to prevent that. automaticReindent = (stateTracker.NeedsReindent && lastCharInserted != '\0') && Editor.EditMode == EditMode.Edit; if (descriptor.SpecialKey == SpecialKey.Return && (reIndent || automaticReindent)) { if (Editor.Options.IndentStyle == IndentStyle.Virtual) { if (Editor.GetLine (Editor.CaretLine).Length == 0) Editor.CaretColumn = Editor.GetVirtualIndentationColumn (Editor.CaretLine); } else { DoReSmartIndent (); } } } const string reindentChars = ";){}"; if (reIndent || descriptor.SpecialKey != SpecialKey.Return && descriptor.SpecialKey != SpecialKey.Tab && automaticReindent && reindentChars.Contains (descriptor.KeyChar)) { using (var undo = Editor.OpenUndoGroup ()) { DoReSmartIndent (); } } HandleOnTheFlyFormatting (descriptor); SafeUpdateIndentEngine (Editor.CaretOffset); lastCharInserted = '\0'; CheckXmlCommentCloseTag (descriptor.KeyChar); return retval; } if (Editor.Options.IndentStyle == IndentStyle.Auto && DefaultSourceEditorOptions.Instance.TabIsReindent && descriptor.SpecialKey == SpecialKey.Tab) { bool retval = base.KeyPress (descriptor); DoReSmartIndent (); CheckXmlCommentCloseTag (descriptor.KeyChar); return retval; } //pass through to the base class, which actually inserts the character //and calls HandleCodeCompletion etc to handles completion var result = base.KeyPress (descriptor); if (!indentationDisabled && (descriptor.SpecialKey == SpecialKey.Return)) { DoReSmartIndent (); } CheckXmlCommentCloseTag (descriptor.KeyChar); HandleOnTheFlyFormatting (descriptor); return result; }
void HandleOnTheFlyFormatting (KeyDescriptor descriptor) { if (descriptor.KeyChar == '{') return; SafeUpdateIndentEngine (Editor.CaretOffset); bool skipFormatting = stateTracker.IsInsideOrdinaryCommentOrString || stateTracker.IsInsidePreprocessorDirective; if (!skipFormatting && !(stateTracker.IsInsideComment || stateTracker.IsInsideString)) { if (DocumentContext.ParsedDocument == null || DocumentContext.ParsedDocument.GetAst<SemanticModel> () == null) return; var document = DocumentContext.AnalysisDocument; if (document == null) return; if (!skipFormatting && service.SupportsFormattingOnTypedCharacter (document, descriptor.KeyChar)) { var caretPosition = Editor.CaretOffset; var token = CSharpEditorFormattingService.GetTokenBeforeTheCaretAsync (document, caretPosition, default(CancellationToken)).Result; if (token.IsMissing || !service.ValidSingleOrMultiCharactersTokenKind (descriptor.KeyChar, token.Kind ()) || token.IsKind (SyntaxKind.EndOfFileToken, SyntaxKind.None)) return; if (CSharpEditorFormattingService.TokenShouldNotFormatOnTypeChar (token)) return; using (var undo = Editor.OpenUndoGroup ()) { if (OnTheFlyFormatting && Editor != null && Editor.EditMode == EditMode.Edit) { OnTheFlyFormatter.FormatStatmentAt (Editor, DocumentContext, Editor.CaretLocation, optionSet: optionSet); } } } } if (OnTheFlyFormatting && descriptor.SpecialKey == SpecialKey.Return) { try { FormatOnReturn (); } catch (Exception e) { LoggingService.LogError ("Exception while formatting", e); } } }
internal static void PostProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor) { }
public override bool KeyPress(KeyDescriptor descriptor) { if ((descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == 'f') || (descriptor.ModifierKeys == 0 && descriptor.SpecialKey == SpecialKey.PageDown)) { EditActions.ScrollPageDown(Editor); return false; } if ((descriptor.ModifierKeys == ModifierKeys.Control && descriptor.KeyChar == 'b') || (descriptor.ModifierKeys == 0 && descriptor.SpecialKey == SpecialKey.PageUp)) { EditActions.ScrollPageUp(Editor); return false; } if (descriptor.ModifierKeys == 0) { uint unicodeKey = descriptor.KeyChar; // remap some function keys to Vi commands if (descriptor.SpecialKey == SpecialKey.Home) unicodeKey = '0'; else if (descriptor.SpecialKey == SpecialKey.End) unicodeKey = '$'; else if (descriptor.SpecialKey == SpecialKey.Left) unicodeKey = 'h'; else if (descriptor.SpecialKey == SpecialKey.Right) unicodeKey = 'l'; else if (descriptor.SpecialKey == SpecialKey.Up) unicodeKey = 'k'; else if (descriptor.SpecialKey == SpecialKey.Down) unicodeKey = 'j'; else if (descriptor.SpecialKey == SpecialKey.Delete) unicodeKey = 'x'; //else if (descriptor.SpecialKey == SpecialKey.Insert) // unicodeKey = 'i'; else if (descriptor.SpecialKey == SpecialKey.BackSpace) unicodeKey = 'h'; if (_command == null) { // build repeat buffer if ((_countString.Length > 0 || unicodeKey > '0') && unicodeKey >= '0' && unicodeKey <= '9') { _countString += Char.ToString((char)unicodeKey); return false; } _command = unicodeKey; } else { _commandArgs.Add((char)unicodeKey); } if (!_commands.ContainsKey((uint)_command)) { _command = null; return false; } CaretOffEol(); if (_commands[(uint)_command](Count, _commandArgs.ToArray())) { Reset(); } } return false; }
public override bool KeyPress(KeyDescriptor descriptor) { var ret = base.KeyPress(descriptor); if (RequestedMode == Mode.None) { UpdateSelection(); } return ret; }
public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, MonoDevelop.Ide.Editor.Extension.KeyDescriptor descriptor) { string partialWord = GetCurrentWord(window, descriptor); int skipChars = 0; bool runParameterCompletionCommand = false; bool runCompletionCompletionCommand = false; var method = Symbol as IMethodSymbol; bool addParens = IdeApp.Preferences.AddParenthesesAfterCompletion; bool addOpeningOnly = IdeApp.Preferences.AddOpeningOnly; var Editor = ext.Editor; var Policy = ext.FormattingPolicy; string insertionText = this.GetInsertionText(); if (addParens && !IsDelegateExpected && method != null && !IsBracketAlreadyInserted(ext, method)) { var line = Editor.GetLine(Editor.CaretLine); //var start = window.CodeCompletionContext.TriggerOffset + partialWord.Length + 2; //var end = line.Offset + line.Length; //string textToEnd = start < end ? Editor.GetTextBetween (start, end) : ""; bool addSpace = Policy.SpaceAfterMethodCallName && MonoDevelop.Ide.Editor.DefaultSourceEditorOptions.Instance.OnTheFlyFormatting; int exprStart = window.CodeCompletionContext.TriggerOffset - 1; while (exprStart > line.Offset) { char ch = Editor.GetCharAt(exprStart); if (ch != '.' && ch != '_' && !char.IsLetterOrDigit(ch)) { break; } exprStart--; } bool insertSemicolon = InsertSemicolon(ext, exprStart); if (Symbol is IMethodSymbol && ((IMethodSymbol)Symbol).MethodKind == MethodKind.Constructor) { insertSemicolon = false; } //int pos; var keys = new [] { SpecialKey.Return, SpecialKey.Tab, SpecialKey.Space }; if (keys.Contains(descriptor.SpecialKey) || descriptor.KeyChar == '.') { if (HasAnyOverloadWithParameters(method)) { if (addOpeningOnly) { insertionText += RequireGenerics(method) ? "<|" : (addSpace ? " (|" : "(|"); skipChars = 0; } else { if (descriptor.KeyChar == '.') { if (RequireGenerics(method)) { insertionText += addSpace ? "<> ()" : "<>()"; } else { insertionText += addSpace ? " ()" : "()"; } skipChars = 0; } else { if (insertSemicolon) { if (RequireGenerics(method)) { insertionText += addSpace ? "<|> ();" : "<|>();"; skipChars = addSpace ? 5 : 4; } else { insertionText += addSpace ? " (|);" : "(|);"; skipChars = 2; } } else { if (RequireGenerics(method)) { insertionText += addSpace ? "<|> ()" : "<|>()"; skipChars = addSpace ? 4 : 3; } else { insertionText += addSpace ? " (|)" : "(|)"; skipChars = 1; } } } } runParameterCompletionCommand = true; } else { if (addOpeningOnly) { insertionText += RequireGenerics(method) ? "<|" : (addSpace ? " (|" : "(|"); skipChars = 0; } else { if (descriptor.KeyChar == '.') { if (RequireGenerics(method)) { insertionText += addSpace ? "<> ()" : "<>()"; } else { insertionText += addSpace ? " ()" : "()"; } skipChars = 0; } else { if (insertSemicolon) { if (RequireGenerics(method)) { insertionText += addSpace ? "<|> ();" : "<|>();"; } else { insertionText += addSpace ? " ();|" : "();|"; } } else { if (RequireGenerics(method)) { insertionText += addSpace ? "<|> ()" : "<|>()"; } else { insertionText += addSpace ? " ()|" : "()|"; } } } } } } if (descriptor.KeyChar == ';') { insertionText += addSpace ? " ()" : "()"; } ka |= KeyActions.Ignore; } if ((DisplayFlags & DisplayFlags.NamedArgument) == DisplayFlags.NamedArgument && IdeApp.Preferences.AddParenthesesAfterCompletion && (descriptor.SpecialKey == SpecialKey.Tab || descriptor.SpecialKey == SpecialKey.Return || descriptor.SpecialKey == SpecialKey.Space)) { if (true /*Policy.AroundAssignmentParentheses */) { insertionText += " "; } insertionText += "="; if (/*Policy.AroundAssignmentParentheses && */ descriptor.SpecialKey != SpecialKey.Space) { insertionText += " "; } runCompletionCompletionCommand = true; } window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, partialWord, insertionText); int offset = Editor.CaretOffset; for (int i = skipChars; i-- > 0;) { Editor.StartSession(new SkipCharSession(Editor.GetCharAt(offset + i))); } if (runParameterCompletionCommand && IdeApp.Workbench != null) { Application.Invoke(delegate { ext.RunParameterCompletionCommand(); }); } if (runCompletionCompletionCommand && IdeApp.Workbench != null) { Application.Invoke(delegate { ext.RunCompletionCommand(); }); } }
public override bool KeyPress (KeyDescriptor descriptor) { var native =(Tuple<Gdk.Key, Gdk.ModifierType>)descriptor.NativeKeyChar; ext.SimulateKeyPress (native.Item1, (uint)descriptor.KeyChar, native.Item2); if (descriptor.SpecialKey == SpecialKey.Escape) return true; return false; }
public virtual bool KeyPress(KeyDescriptor descriptor) { // build repeat buffer if (_command == null && (_count > 0 || descriptor.KeyChar > '0') && descriptor.KeyChar >= '0' && descriptor.KeyChar <= '9') { _count = (_count * 10) + (descriptor.KeyChar - 48); return false; } _buf += Char.ToString(descriptor.KeyChar); if (_command == null) { if (descriptor.ModifierKeys == ModifierKeys.Control) _buf = "^" + _buf; if (!SpecialKeyCommandMap.TryGetValue(descriptor.SpecialKey, out _command)) { if (!CommandMap.ContainsKey(_buf)) { foreach (var k in CommandMap.Keys) { if (k.StartsWith(_buf, StringComparison.Ordinal)) return false; } Reset(); return false; } _command = CommandMap[_buf]; } _buf = ""; if (_command.TakeArgument) return false; } CaretOffEol(); RequestedMode = _command.RunCommand(_count, (char)(_buf.Length > 0 ? _buf[0] : 0)); _command = null; Reset(); CaretOffEol(); return false; }
public static bool PreProcessKeyEvent (KeyDescriptor descriptor) { if (!IsVisible) return false; if (descriptor.KeyChar != '\0') { wnd.EndOffset = wnd.StartOffset + wnd.CurrentPartialWord.Length + 1; } return wnd.PreProcessKeyEvent (descriptor); }
public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, MonoDevelop.Ide.Editor.Extension.KeyDescriptor descriptor) { if (this.CompletionText == "sizeof" || this.CompletionText == "nameof" || this.CompletionText == "typeof") { string partialWord = GetCurrentWord(window, descriptor); int skipChars = 0; bool runCompletionCompletionCommand = false; var method = Symbol as IMethodSymbol; bool addParens = DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket; var Editor = ext.Editor; var Policy = ext.FormattingPolicy; string insertionText = this.CompletionText; if (addParens && !IsBracketAlreadyInserted(ext)) { var line = Editor.GetLine(Editor.CaretLine); //var start = window.CodeCompletionContext.TriggerOffset + partialWord.Length + 2; //var end = line.Offset + line.Length; //string textToEnd = start < end ? Editor.GetTextBetween (start, end) : ""; bool addSpace = Policy.SpaceAfterMethodCallName && MonoDevelop.Ide.Editor.DefaultSourceEditorOptions.Instance.OnTheFlyFormatting; var keys = new [] { SpecialKey.Return, SpecialKey.Tab, SpecialKey.Space }; if (keys.Contains(descriptor.SpecialKey) || descriptor.KeyChar == ' ') { insertionText += addSpace ? " (|)" : "(|)"; } ka |= KeyActions.Ignore; } window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, partialWord, insertionText); int offset = Editor.CaretOffset; for (int i = skipChars - 1; i-- > 0;) { Editor.StartSession(new SkipCharSession(Editor.GetCharAt(offset))); offset++; } if (runCompletionCompletionCommand && IdeApp.Workbench != null) { Application.Invoke((o, args) => { ext.RunCompletionCommand(); }); } } else { base.InsertCompletionText(window, ref ka, descriptor); } }
/// <summary> /// Return true if the key press should be processed by the editor. /// When a key is pressed, and before the key is processed by the editor, this method will be invoked. /// </summary> public virtual async Task <bool> KeyPress(KeyDescriptor descriptor) { return(Next == null || await Next.KeyPress(descriptor)); }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { // insert add/remove event handler code after +=/-= var editor = factory.Ext.Editor; bool AddSemicolon = true; var position = window.CodeCompletionContext.TriggerOffset; editor.ReplaceText (position, editor.CaretOffset - position, this.DisplayText + (AddSemicolon ? ";" : "")); var document = IdeApp.Workbench.ActiveDocument; var parsedDocument = document.UpdateParseDocument ().Result; var semanticModel = parsedDocument.GetAst<SemanticModel> (); var declaringType = semanticModel.GetEnclosingSymbol<INamedTypeSymbol> (position, default(CancellationToken)); var enclosingSymbol = semanticModel.GetEnclosingSymbol<ISymbol> (position, default(CancellationToken)); var insertionPoints = InsertionPointService.GetInsertionPoints ( document.Editor, parsedDocument, declaringType, editor.CaretOffset ); var options = new InsertionModeOptions ( GettextCatalog.GetString ("Create new method"), insertionPoints, point => { if (!point.Success) return; var indent = "\t"; var sb = new StringBuilder (); if (enclosingSymbol != null && enclosingSymbol.IsStatic) sb.Append ("static "); sb.Append ("void "); int pos2 = sb.Length; sb.Append (this.DisplayText); sb.Append (' '); sb.Append("("); var delegateMethod = delegateType.GetDelegateInvokeMethod(); for (int k = 0; k < delegateMethod.Parameters.Length; k++) { if (k > 0) { sb.Append(", "); } sb.Append (RoslynCompletionData.SafeMinimalDisplayString (delegateMethod.Parameters [k], semanticModel, position, MonoDevelop.Ide.TypeSystem.Ambience.LabelFormat)); } sb.Append(")"); sb.Append (editor.EolMarker); sb.Append (indent); sb.Append ("{"); sb.Append (editor.EolMarker); sb.Append (indent); sb.Append (editor.Options.GetIndentationString ()); //int cursorPos = pos + sb.Length; sb.Append (editor.EolMarker); sb.Append (indent); sb.Append ("}"); point.InsertionPoint.Insert (document.Editor, document, sb.ToString ()); // // start text link mode after insert // var links = new List<TextLink> (); // var link = new TextLink ("name"); // // link.AddLink (new TextSegment (initialOffset, this.DisplayText.Length)); // link.AddLink (new TextSegment (initialOffset + pos + pos2, this.DisplayText.Length)); // links.Add (link); // editor.StartTextLinkMode (new TextLinkModeOptions (links)); } ); editor.StartInsertionMode (options); }
public override void InsertCompletionText (CompletionListWindow window, ref KeyActions ka, KeyDescriptor descriptor) { var editor = ext.Editor; bool isExplicit = false; // if (member.DeclaringTypeDefinition.Kind == TypeKind.Interface) { // foreach (var m in type.Members) { // if (m.Name == member.Name && !m.ReturnType.Equals (member.ReturnType)) { // isExplicit = true; // break; // } // } // } // var resolvedType = type.Resolve (ext.Project).GetDefinition (); // if (ext.Project != null) // generator.PolicyParent = ext.Project.Policies; var result = CSharpCodeGenerator.CreatePartialMemberImplementation (ext.DocumentContext, ext.Editor, currentType, currentType.Locations.First (), Symbol, isExplicit, factory.SemanticModel); string sb = result.Code.TrimStart (); int trimStart = result.Code.Length - sb.Length; sb = sb.TrimEnd (); var lastRegion = result.BodyRegions.LastOrDefault (); var region = lastRegion == null? null : new CodeGeneratorBodyRegion (lastRegion.StartOffset - trimStart, lastRegion.EndOffset - trimStart); int targetCaretPosition; int selectionEndPosition = -1; if (region != null && region.IsValid) { targetCaretPosition = declarationBegin + region.EndOffset; } else { targetCaretPosition = declarationBegin + sb.Length; } editor.ReplaceText (declarationBegin, editor.CaretOffset - declarationBegin, sb); if (selectionEndPosition > 0) { editor.CaretOffset = selectionEndPosition; editor.SetSelection (targetCaretPosition, selectionEndPosition); } else { editor.CaretOffset = targetCaretPosition; } OnTheFlyFormatter.Format (editor, ext.DocumentContext, declarationBegin, declarationBegin + sb.Length); editor.CaretLine--; }
public bool PostProcessKey (CompletionListWindow listWindow, KeyDescriptor descriptor, out KeyActions keyAction) { keyAction = KeyActions.None; if (descriptor.KeyChar == '.') { return true; } return false; }
// When a key is pressed, and before the key is processed by the editor, this method will be invoked. // Return true if the key press should be processed by the editor. public override bool KeyPress(KeyDescriptor descriptor) { if (!IsActiveExtension()) { return(base.KeyPress(descriptor)); } bool res; if (CurrentCompletionContext != null) { if (CompletionWindowManager.PreProcessKeyEvent(descriptor)) { CompletionWindowManager.PostProcessKeyEvent(descriptor); autoHideCompletionWindow = true; // in named parameter case leave the parameter window open. autoHideParameterWindow = descriptor.KeyChar != ':'; if (!autoHideParameterWindow && ParameterInformationWindowManager.IsWindowVisible) { ParameterInformationWindowManager.PostProcessKeyEvent(this, CompletionWidget, descriptor); } return(false); } autoHideCompletionWindow = autoHideParameterWindow = false; } if (ParameterInformationWindowManager.IsWindowVisible) { if (ParameterInformationWindowManager.ProcessKeyEvent(this, CompletionWidget, descriptor)) { return(false); } autoHideCompletionWindow = autoHideParameterWindow = false; } // int oldPos = Editor.CursorPosition; // int oldLen = Editor.TextLength; char deleteOrBackspaceTriggerChar = '\0'; if (descriptor.SpecialKey == SpecialKey.Delete && Editor.CaretOffset < Editor.Length) { deleteOrBackspaceTriggerChar = Editor.GetCharAt(Editor.CaretOffset); } if (descriptor.SpecialKey == SpecialKey.BackSpace && Editor.CaretOffset > 0) { deleteOrBackspaceTriggerChar = Editor.GetCharAt(Editor.CaretOffset - 1); } res = base.KeyPress(descriptor); if (Editor.EditMode == EditMode.TextLink && Editor.TextLinkPurpose == TextLinkPurpose.Rename) { return(res); } if (descriptor.KeyChar == (char)16 || descriptor.KeyChar == (char)17) { return(res); } CompletionWindowManager.PostProcessKeyEvent(descriptor); var ignoreMods = ModifierKeys.Control | ModifierKeys.Alt | ModifierKeys.Command; // Handle parameter completion if (ParameterInformationWindowManager.IsWindowVisible) { ParameterInformationWindowManager.PostProcessKeyEvent(this, CompletionWidget, descriptor); } if ((descriptor.ModifierKeys & ignoreMods) != 0) { return(res); } // don't complete on block selection if (/*!EnableCodeCompletion ||*/ Editor.SelectionMode == MonoDevelop.Ide.Editor.SelectionMode.Block) { return(res); } // Handle code completion if (descriptor.KeyChar != '\0' && CompletionWidget != null && !CompletionWindowManager.IsVisible) { completionTokenSrc.Cancel(); CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; completionTokenSrc = new CancellationTokenSource(); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleCodeCompletionAsync(CurrentCompletionContext, new CompletionTriggerInfo(CompletionTriggerReason.CharTyped, descriptor.KeyChar), token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow(this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate(object o, EventArgs a) { completionTokenSrc.Cancel(); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith(t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) { return; } var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext(Editor.CaretOffset - triggerWordLength); if (result.TriggerWordStart >= 0) { CurrentCompletionContext.TriggerOffset = result.TriggerWordStart; } CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow(result, CurrentCompletionContext)) { CurrentCompletionContext = null; } } else { CompletionWindowManager.HideWindow(); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { } catch (AggregateException) { } } if ((descriptor.SpecialKey == SpecialKey.Delete || descriptor.SpecialKey == SpecialKey.BackSpace) && CompletionWidget != null && !CompletionWindowManager.IsVisible) { if (!char.IsLetterOrDigit(deleteOrBackspaceTriggerChar) && deleteOrBackspaceTriggerChar != '_') { return(res); } CurrentCompletionContext = CompletionWidget.CurrentCodeCompletionContext; int cpos, wlen; if (!GetCompletionCommandOffset(out cpos, out wlen)) { cpos = Editor.CaretOffset; wlen = 0; } CurrentCompletionContext.TriggerOffset = cpos; CurrentCompletionContext.TriggerWordLength = wlen; completionTokenSrc.Cancel(); completionTokenSrc = new CancellationTokenSource(); var caretOffset = Editor.CaretOffset; var token = completionTokenSrc.Token; try { var task = HandleCodeCompletionAsync(CurrentCompletionContext, new CompletionTriggerInfo(CompletionTriggerReason.BackspaceOrDeleteCommand, deleteOrBackspaceTriggerChar), token); if (task != null) { // Show the completion window in two steps. The call to PrepareShowWindow creates the window but // it doesn't show it. It is used only to process the keys while the completion data is being retrieved. CompletionWindowManager.PrepareShowWindow(this, descriptor.KeyChar, CompletionWidget, CurrentCompletionContext); EventHandler windowClosed = delegate(object o, EventArgs a) { completionTokenSrc.Cancel(); }; CompletionWindowManager.WindowClosed += windowClosed; task.ContinueWith(t => { CompletionWindowManager.WindowClosed -= windowClosed; if (token.IsCancellationRequested) { return; } var result = t.Result; if (result != null) { int triggerWordLength = result.TriggerWordLength + (Editor.CaretOffset - caretOffset); if (triggerWordLength > 0 && (triggerWordLength < Editor.CaretOffset || (triggerWordLength == 1 && Editor.CaretOffset == 1))) { CurrentCompletionContext = CompletionWidget.CreateCodeCompletionContext(Editor.CaretOffset - triggerWordLength); if (result.TriggerWordStart >= 0) { CurrentCompletionContext.TriggerOffset = result.TriggerWordStart; } CurrentCompletionContext.TriggerWordLength = triggerWordLength; } // Now show the window for real. if (!CompletionWindowManager.ShowWindow(result, CurrentCompletionContext)) { CurrentCompletionContext = null; } else { CompletionWindowManager.Wnd.StartOffset = CurrentCompletionContext.TriggerOffset; } } else { CompletionWindowManager.HideWindow(); CurrentCompletionContext = null; } }, Runtime.MainTaskScheduler); } else { CurrentCompletionContext = null; } } catch (TaskCanceledException) { CurrentCompletionContext = null; } catch (AggregateException) { CurrentCompletionContext = null; } } if (CompletionWidget != null) { CodeCompletionContext ctx = CompletionWidget.CurrentCodeCompletionContext; var newparameterHintingSrc = new CancellationTokenSource(); var token = newparameterHintingSrc.Token; try { var task = HandleParameterCompletionAsync(ctx, descriptor.KeyChar, token); if (task != null) { parameterHintingSrc.Cancel(); parameterHintingSrc = newparameterHintingSrc; parameterHingtingCursorPositionChanged = false; task.ContinueWith(t => { if (!token.IsCancellationRequested && t.Result != null) { ParameterInformationWindowManager.ShowWindow(this, CompletionWidget, ctx, t.Result); if (parameterHingtingCursorPositionChanged) { ParameterInformationWindowManager.UpdateCursorPosition(this, CompletionWidget); } } }, token, TaskContinuationOptions.None, Runtime.MainTaskScheduler); } else { //Key was typed that was filtered out, no heavy processing will be performed(task==null) //but we still want to update ParameterInfo window to avoid displaying it outside method call parameterHingtingCursorPositionChanged = true; } } catch (TaskCanceledException) { } catch (AggregateException) { } } return(res); }
/// <summary> /// Return true if the key press should be processed by the editor. /// When a key is pressed, and before the key is processed by the editor, this method will be invoked. /// </summary> public virtual bool KeyPress(KeyDescriptor descriptor) { return(Next == null || Next.KeyPress(descriptor)); }
public override bool Handle (TextEditor editor, DocumentContext ctx, KeyDescriptor descriptor) { int braceIndex = openBrackets.IndexOf (descriptor.KeyChar); if (braceIndex < 0) return false; var extEditor = ((SourceEditorView)editor.Implementation).SourceEditorWidget.TextEditor; var line = extEditor.Document.GetLine (extEditor.Caret.Line); if (line == null) return false; bool inStringOrComment = false; var stack = line.StartSpan.Clone (); var sm = extEditor.Document.SyntaxMode as SyntaxMode; if (sm != null) // extEditor.Caret.Offset - 1 means we care if we were inside string // before typing current char Mono.TextEditor.Highlighting.SyntaxModeService.ScanSpans (extEditor.Document, sm, sm, stack, line.Offset, extEditor.Caret.Offset - 1); foreach (var span in stack) { if (string.IsNullOrEmpty (span.Color)) continue; if (span.Color.StartsWith ("String", StringComparison.Ordinal) || span.Color.StartsWith ("Comment", StringComparison.Ordinal) || span.Color.StartsWith ("Xml Attribute Value", StringComparison.Ordinal)) { inStringOrComment = true; break; } } char insertionChar = '\0'; bool insertMatchingBracket = false; if (!inStringOrComment) { char closingBrace = closingBrackets [braceIndex]; char openingBrace = openBrackets [braceIndex]; int count = 0; foreach (char curCh in ExtensibleTextEditor.GetTextWithoutCommentsAndStrings(extEditor.Document, 0, extEditor.Document.TextLength)) { if (curCh == openingBrace) { count++; } else if (curCh == closingBrace) { count--; } } if (count >= 0) { insertMatchingBracket = true; insertionChar = closingBrace; } } if (insertMatchingBracket) { using (var undo = editor.OpenUndoGroup ()) { editor.EnsureCaretIsNotVirtual (); editor.InsertAtCaret (insertionChar.ToString ()); editor.CaretOffset--; editor.StartSession (new SkipCharSession (insertionChar)); } return true; } return false; }
public static void PostProcessKeyEvent (KeyDescriptor descriptor) { if (!IsVisible) return; wnd.PostProcessKeyEvent (descriptor); }
public abstract bool Handle(TextEditor editor, DocumentContext ctx, KeyDescriptor descriptor);