async void CompletionWindowManager_WindowClosed(object sender, EventArgs e) { var document = DocumentContext.AnalysisDocument; if (document == null) { return; } var caretPosition = Editor.CaretOffset; var token = await CSharpEditorFormattingService.GetTokenBeforeTheCaretAsync(document, caretPosition, default(CancellationToken)).ConfigureAwait(false); if (token.IsMissing || !token.Parent.IsKind(SyntaxKind.ElseDirectiveTrivia)) { return; } var tokenRange = Microsoft.CodeAnalysis.CSharp.Utilities.FormattingRangeHelper.FindAppropriateRange(token); if (tokenRange == null || !tokenRange.HasValue || tokenRange.Value.Item1.Equals(tokenRange.Value.Item2)) { return; } var value = tokenRange.Value; using (var undo = Editor.OpenUndoGroup()) { OnTheFlyFormatter.Format(Editor, DocumentContext, value.Item1.SpanStart, value.Item2.Span.End, optionSet: optionSet); } }
void RunFormatter(DocumentLocation location) { if (OnTheFlyFormatting && textEditorData != null && !(textEditorData.CurrentMode is TextLinkEditMode) && !(textEditorData.CurrentMode is InsertionCursorEditMode)) { OnTheFlyFormatter.Format(Document, location); } }
void RunFormatter(MonoDevelop.Ide.Editor.DocumentLocation location) { if (!OnTheFlyFormatting || Editor == null || Editor.EditMode != EditMode.Edit) { return; } var offset = Editor.LocationToOffset(location); OnTheFlyFormatter.Format(Editor, DocumentContext, offset, offset, optionSet: optionSet); }
public override async Task PostFomatPastedText(int insertionOffset, int insertedChars) { if (indent.Editor.Options.IndentStyle == IndentStyle.None || indent.Editor.Options.IndentStyle == IndentStyle.Auto) { return; } if (DefaultSourceEditorOptions.Instance.OnTheFlyFormatting) { var tree = await indent.DocumentContext.AnalysisDocument.GetSyntaxTreeAsync(); var startLine = indent.Editor.GetLineByOffset(insertionOffset); var endLine = indent.Editor.GetLineByOffset(insertionOffset + insertedChars); int lineStartOffset = startLine.Offset != endLine.Offset ? startLine.Offset : insertionOffset; int formatCharsCount = insertedChars + (insertionOffset - lineStartOffset); var policy = indent.DocumentContext.GetFormattingPolicy(); var textPolicy = indent.DocumentContext.Project.Policies.Get <Ide.Gui.Content.TextStylePolicy> (indent.Editor.MimeType); var optionSet = policy.CreateOptions(textPolicy); var span = new TextSpan(lineStartOffset, formatCharsCount); var doc = await Formatter.FormatAsync(indent.DocumentContext.AnalysisDocument, span, optionSet); OnTheFlyFormatter.ApplyNewTree(indent.Editor, lineStartOffset, true, span, tree, await doc.GetSyntaxTreeAsync()); return; } // Just correct the start line of the paste operation - the text is already indented. var curLine = indent.Editor.GetLineByOffset(insertionOffset); var curLineOffset = curLine.Offset; indent.SafeUpdateIndentEngine(curLineOffset); if (!indent.stateTracker.IsInsideOrdinaryCommentOrString) { int pos = curLineOffset; string curIndent = curLine.GetIndentation(indent.Editor); int nlwsp = curIndent.Length; if (!indent.stateTracker.LineBeganInsideMultiLineComment || (nlwsp < curLine.LengthIncludingDelimiter && indent.Editor.GetCharAt(curLineOffset + nlwsp) == '*')) { // Possibly replace the indent indent.SafeUpdateIndentEngine(curLineOffset + curLine.Length); string newIndent = indent.stateTracker.ThisLineIndent; if (newIndent != curIndent) { if (CompletionWindowManager.IsVisible) { if (pos < CompletionWindowManager.CodeCompletionContext.TriggerOffset) { CompletionWindowManager.CodeCompletionContext.TriggerOffset -= nlwsp; } } indent.Editor.ReplaceText(pos, nlwsp, newIndent); // textEditorData.Document.CommitLineUpdate (textEditorData.CaretLine); } } } indent.Editor.FixVirtualIndentation(); }
void HandleOnTheFlyFormatting(KeyDescriptor descriptor) { if (descriptor.KeyChar == '{') { return; } SafeUpdateIndentEngine(Editor.CaretOffset); bool skipFormatting = stateTracker.IsInsideOrdinaryCommentOrString; 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) || token.IsKind(SyntaxKind.None)) { return; } if (CSharpEditorFormattingService.TokenShouldNotFormatOnTypeChar(token)) { return; } using (var undo = Editor.OpenUndoGroup()) { if (OnTheFlyFormatting && Editor != null && Editor.EditMode == EditMode.Edit) { var oldVersion = Editor.Version; OnTheFlyFormatter.FormatStatmentAt(Editor, DocumentContext, Editor.CaretLocation, optionSet: optionSet); if (oldVersion.CompareAge(Editor.Version) != 0) { CompletionWindowManager.HideWindow(); } } } } } if (OnTheFlyFormatting && descriptor.SpecialKey == SpecialKey.Return) { try { FormatOnReturn(); } catch (Exception e) { LoggingService.LogError("Exception while formatting", e); } } }
/* void TextCut (object sender, ReplaceEventArgs e) * { * if (!string.IsNullOrEmpty (e.Value) || e.Count == 0) * return; * RunFormatterAt (e.Offset); * }*/ void RunFormatterAt(int offset) { if (PropertyService.Get("OnTheFlyFormatting", false) && textEditorData != null && Document != null) { // textEditorData.Document.TextReplaced -= TextCut; ProjectDom dom = Document.Dom; DocumentLocation loc = textEditorData.Document.OffsetToLocation(offset); DomLocation location = new DomLocation(loc.Line, loc.Column); // CSharpFormatter.Format (textEditorData, dom, Document.CompilationUnit, location); OnTheFlyFormatter.Format(Document, dom, location); // textEditorData.Document.TextReplaced += TextCut; } }
void RunFormatter() { if (PropertyService.Get("OnTheFlyFormatting", false) && textEditorData != null && !(textEditorData.CurrentMode is TextLinkEditMode)) { // textEditorData.Document.TextReplaced -= TextCut; ProjectDom dom = ProjectDomService.GetProjectDom(Document.Project); if (dom == null) { dom = ProjectDomService.GetFileDom(Document.FileName); } DomLocation location = new DomLocation(textEditorData.Caret.Location.Line + (lastCharInserted == '\n' ? -1 : 0), textEditorData.Caret.Location.Column); // CSharpFormatter.Format (textEditorData, dom, Document.CompilationUnit, location); OnTheFlyFormatter.Format(Document, dom, location, lastCharInserted == '\n'); // textEditorData.Document.TextReplaced += TextCut; } }
public override void PostFomatPastedText(int insertionOffset, int insertedChars) { if (indent.Editor.Options.IndentStyle == IndentStyle.None || indent.Editor.Options.IndentStyle == IndentStyle.Auto) { return; } if (DefaultSourceEditorOptions.Instance.OnTheFlyFormatting) { OnTheFlyFormatter.Format(indent.Editor, indent.DocumentContext, insertionOffset, insertionOffset + insertedChars); return; } // Just correct the start line of the paste operation - the text is already indented. var curLine = indent.Editor.GetLineByOffset(insertionOffset); var curLineOffset = curLine.Offset; indent.SafeUpdateIndentEngine(curLineOffset); if (!indent.stateTracker.IsInsideOrdinaryCommentOrString) { int pos = curLineOffset; string curIndent = curLine.GetIndentation(indent.Editor); int nlwsp = curIndent.Length; if (!indent.stateTracker.LineBeganInsideMultiLineComment || (nlwsp < curLine.LengthIncludingDelimiter && indent.Editor.GetCharAt(curLineOffset + nlwsp) == '*')) { // Possibly replace the indent indent.SafeUpdateIndentEngine(curLineOffset + curLine.Length); string newIndent = indent.stateTracker.ThisLineIndent; if (newIndent != curIndent) { if (CompletionWindowManager.IsVisible) { if (pos < CompletionWindowManager.CodeCompletionContext.TriggerOffset) { CompletionWindowManager.CodeCompletionContext.TriggerOffset -= nlwsp; } } indent.Editor.ReplaceText(pos, nlwsp, newIndent); // textEditorData.Document.CommitLineUpdate (textEditorData.CaretLine); } } } indent.Editor.FixVirtualIndentation(); }
async void FormatOnReturn(CancellationToken cancellationToken = default(CancellationToken)) { var document = DocumentContext.AnalysisDocument; if (document == null) { return; } var caretPosition = Editor.CaretOffset; var token = await CSharpEditorFormattingService.GetTokenBeforeTheCaretAsync(document, caretPosition, cancellationToken).ConfigureAwait(false); if (token.IsMissing) { return; } string text = null; if (service.IsInvalidToken(token, ref text)) { return; } // Check to see if the token is ')' and also the parent is a using statement. If not, bail if (CSharpEditorFormattingService.TokenShouldNotFormatOnReturn(token)) { return; } var tokenRange = Microsoft.CodeAnalysis.CSharp.Utilities.FormattingRangeHelper.FindAppropriateRange(token); if (tokenRange == null || !tokenRange.HasValue || tokenRange.Value.Item1.Equals(tokenRange.Value.Item2)) { return; } var value = tokenRange.Value; using (var undo = Editor.OpenUndoGroup()) { OnTheFlyFormatter.Format(Editor, DocumentContext, value.Item1.SpanStart, value.Item2.Span.End, optionSet: optionSet); } }
public override bool KeyPress (Gdk.Key key, char keyChar, Gdk.ModifierType modifier) { bool skipFormatting = StateTracker.IsInsideOrdinaryCommentOrString || StateTracker.IsInsidePreprocessorDirective; cursorPositionBeforeKeyPress = textEditorData.Caret.Offset; bool isSomethingSelected = textEditorData.IsSomethingSelected; if (key == Gdk.Key.BackSpace && textEditorData.Caret.Offset == lastInsertedSemicolon) { textEditorData.Document.Undo (); lastInsertedSemicolon = -1; return false; } lastInsertedSemicolon = -1; if (keyChar == ';' && !(textEditorData.CurrentMode is TextLinkEditMode) && !DoInsertTemplate () && !isSomethingSelected && PropertyService.Get ( "SmartSemicolonPlacement", false )) { bool retval = base.KeyPress (key, keyChar, modifier); DocumentLine curLine = textEditorData.Document.GetLine (textEditorData.Caret.Line); string text = textEditorData.Document.GetTextAt (curLine); if (!(text.EndsWith (";", StringComparison.Ordinal) || text.Trim ().StartsWith ("for", StringComparison.Ordinal))) { int guessedOffset; if (GuessSemicolonInsertionOffset (textEditorData, curLine, textEditorData.Caret.Offset, out guessedOffset)) { using (var undo = textEditorData.OpenUndoGroup ()) { textEditorData.Remove (textEditorData.Caret.Offset - 1, 1); textEditorData.Caret.Offset = guessedOffset; lastInsertedSemicolon = textEditorData.Caret.Offset + 1; retval = base.KeyPress (key, keyChar, modifier); } } } using (var undo = textEditorData.OpenUndoGroup ()) { if (OnTheFlyFormatting && textEditorData != null && !(textEditorData.CurrentMode is TextLinkEditMode) && !(textEditorData.CurrentMode is InsertionCursorEditMode)) { OnTheFlyFormatter.FormatStatmentAt (Document, textEditorData.Caret.Location); } } return retval; } if (key == Gdk.Key.Tab) { SafeUpdateIndentEngine (textEditorData.Caret.Offset); if (stateTracker.IsInsideStringLiteral && !textEditorData.IsSomethingSelected) { var lexer = new CSharpCompletionEngineBase.MiniLexer (textEditorData.Document.GetTextAt (0, textEditorData.Caret.Offset)); lexer.Parse (); if (lexer.IsInString) { textEditorData.InsertAtCaret ("\\t"); return false; } } } if (key == Gdk.Key.Tab && DefaultSourceEditorOptions.Instance.TabIsReindent && !CompletionWindowManager.IsVisible && !(textEditorData.CurrentMode is TextLinkEditMode) && !DoInsertTemplate () && !isSomethingSelected) { ReindentOnTab (); return false; } SafeUpdateIndentEngine (textEditorData.Caret.Offset); if (!stateTracker.IsInsideOrdinaryCommentOrString) { if (keyChar == '@') { var retval = base.KeyPress (key, keyChar, modifier); int cursor = textEditorData.Caret.Offset; if (cursor < textEditorData.Length && textEditorData.GetCharAt (cursor) == '"') ConvertNormalToVerbatimString (textEditorData, cursor + 1); return retval; } } //do the smart indent if (textEditorData.Options.IndentStyle == IndentStyle.Smart || textEditorData.Options.IndentStyle == IndentStyle.Virtual) { bool retval; //capture some of the current state int oldBufLen = textEditorData.Length; int oldLine = textEditorData.Caret.Line + 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 = textEditorData.OpenUndoGroup ()) { DoPreInsertionSmartIndent (key); } 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 (key, keyChar, modifier); //handle inserted characters if (textEditorData.Caret.Offset <= 0 || textEditorData.IsSomethingSelected) return retval; lastCharInserted = TranslateKeyCharForIndenter (key, keyChar, textEditorData.GetCharAt (textEditorData.Caret.Offset - 1)); if (lastCharInserted == '\0') return retval; using (var undo = textEditorData.OpenUndoGroup ()) { SafeUpdateIndentEngine (textEditorData.Caret.Offset); if (key == Gdk.Key.Return && modifier == Gdk.ModifierType.ControlMask) { FixLineStart (textEditorData, stateTracker, textEditorData.Caret.Line + 1); } else { if (!(oldLine == textEditorData.Caret.Line + 1 && lastCharInserted == '\n') && (oldBufLen != textEditorData.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 (textEditorData.Caret.Offset); automaticReindent = (stateTracker.NeedsReindent && lastCharInserted != '\0'); if (key == Gdk.Key.Return && (reIndent || automaticReindent)) { if (textEditorData.Options.IndentStyle == IndentStyle.Virtual) { if (textEditorData.GetLine (textEditorData.Caret.Line).Length == 0) textEditorData.Caret.Column = textEditorData.IndentationTracker.GetVirtualIndentationColumn (textEditorData.Caret.Location); } else { DoReSmartIndent (); } } } if (reIndent || key != Gdk.Key.Return && automaticReindent) { using (var undo = textEditorData.OpenUndoGroup ()) { DoReSmartIndent (); } } if (!skipFormatting) { if (keyChar == ';' || keyChar == '}') { using (var undo = textEditorData.OpenUndoGroup ()) { if (OnTheFlyFormatting && textEditorData != null && !(textEditorData.CurrentMode is TextLinkEditMode) && !(textEditorData.CurrentMode is InsertionCursorEditMode)) { OnTheFlyFormatter.FormatStatmentAt (Document, textEditorData.Caret.Location); } } } } SafeUpdateIndentEngine (textEditorData.Caret.Offset); lastCharInserted = '\0'; CheckXmlCommentCloseTag (keyChar); return retval; } if (textEditorData.Options.IndentStyle == IndentStyle.Auto && DefaultSourceEditorOptions.Instance.TabIsReindent && key == Gdk.Key.Tab) { bool retval = base.KeyPress (key, keyChar, modifier); DoReSmartIndent (); CheckXmlCommentCloseTag (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 (key, keyChar, modifier); if (key == Gdk.Key.Return || key == Gdk.Key.KP_Enter) { DoReSmartIndent (); } CheckXmlCommentCloseTag (keyChar); if (!skipFormatting && keyChar == '}') RunFormatter (new DocumentLocation (textEditorData.Caret.Location.Line, textEditorData.Caret.Location.Column)); return result; }
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 returnBetweenBraces = descriptor.SpecialKey == SpecialKey.Return && descriptor.ModifierKeys == ModifierKeys.None && Editor.CaretOffset > 0 && Editor.CaretOffset < Editor.Length && Editor.GetCharAt(Editor.CaretOffset - 1) == '{' && Editor.GetCharAt(Editor.CaretOffset) == '}' && !stateTracker.IsInsideOrdinaryCommentOrString; 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); if (descriptor.KeyChar == '/' && stateTracker.IsInsideMultiLineComment) { if (Editor.CaretOffset - 3 >= 0 && Editor.GetCharAt(Editor.CaretOffset - 3) == '*' && Editor.GetCharAt(Editor.CaretOffset - 2) == ' ') { using (var undo = Editor.OpenUndoGroup()) { Editor.RemoveText(Editor.CaretOffset - 2, 1); } } } //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()) { if (returnBetweenBraces) { var oldOffset = Editor.CaretOffset; Editor.InsertAtCaret(Editor.EolMarker); DoReSmartIndent(); Editor.CaretOffset = oldOffset; } 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); }
protected override void OnTheFlyFormatImplementation(TextEditor editor, DocumentContext context, int startOffset, int length) { OnTheFlyFormatter.Format(editor, context, startOffset, startOffset + length); }
public override void OnTheFlyFormat(MonoDevelop.Ide.Gui.Document doc, int startOffset, int endOffset) { OnTheFlyFormatter.Format(doc, startOffset, endOffset); }