public override bool KeyPress (Gdk.Key key, char keyChar, Gdk.ModifierType modifier)
{
bool skipFormatting = StateTracker.Engine.IsInsideOrdinaryCommentOrString ||
StateTracker.Engine.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) {
stateTracker.UpdateEngine ();
if (stateTracker.Engine.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) {
int cursor = textEditorData.Caret.Offset;
if (stateTracker.Engine.IsInsideVerbatimString && cursor > 0 && cursor < textEditorData.Document.TextLength && textEditorData.GetCharAt (cursor - 1) == '"')
stateTracker.UpdateEngine (cursor + 1);
if (stateTracker.Engine.IsInsideVerbatimString) {
// insert normal tab inside @" ... "
if (textEditorData.IsSomethingSelected) {
textEditorData.SelectedText = "\t";
} else {
textEditorData.Insert (cursor, "\t");
}
textEditorData.Document.CommitLineUpdate (textEditorData.Caret.Line);
} else if (cursor >= 1) {
if (textEditorData.Caret.Column > 1) {
int delta = cursor - cursorPositionBeforeKeyPress;
if (delta < 2 && delta > 0) {
textEditorData.Remove (cursor - delta, delta);
textEditorData.Caret.Offset = cursor - delta;
textEditorData.Document.CommitLineUpdate (textEditorData.Caret.Line);
}
}
stateTracker.UpdateEngine ();
DoReSmartIndent ();
}
return false;
}
//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 hadSelection = textEditorData.IsSomethingSelected;
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);
}
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 ()) {
stateTracker.UpdateEngine ();
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, hadSelection, out reIndent);
}
//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
stateTracker.UpdateEngine ();
automaticReindent = (stateTracker.Engine.NeedsReindent && lastCharInserted != '\0');
if (key == Gdk.Key.Return && (reIndent || automaticReindent))
DoReSmartIndent ();
}
if (key != Gdk.Key.Return && (reIndent || 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);
}
}
}
}
stateTracker.UpdateEngine ();
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);
CheckXmlCommentCloseTag (keyChar);
if (!skipFormatting && keyChar == '}')
RunFormatter (new DocumentLocation (textEditorData.Caret.Location.Line, textEditorData.Caret.Location.Column));
return result;
}
public static bool FixLineStart (TextEditorData textEditorData, DocumentStateTracker<CSharpIndentEngine> stateTracker, int lineNumber)
{
if (lineNumber > DocumentLocation.MinLine) {
DocumentLine line = textEditorData.Document.GetLine (lineNumber);
if (line == null)
return false;
DocumentLine prevLine = textEditorData.Document.GetLine (lineNumber - 1);
if (prevLine == null)
return false;
string trimmedPreviousLine = textEditorData.Document.GetTextAt (prevLine).TrimStart ();
//xml doc comments
//check previous line was a doc comment
//check there's a following line?
if (trimmedPreviousLine.StartsWith ("///", StringComparison.Ordinal)) {
if (textEditorData.GetTextAt (line.Offset, line.Length).TrimStart ().StartsWith ("///", StringComparison.Ordinal))
return false;
//check that the newline command actually inserted a newline
textEditorData.EnsureCaretIsNotVirtual ();
string nextLine = textEditorData.Document.GetTextAt (textEditorData.Document.GetLine (lineNumber + 1)).TrimStart ();
if (trimmedPreviousLine.Length > "///".Length || nextLine.StartsWith ("///", StringComparison.Ordinal)) {
var insertionPoint = line.Offset + line.GetIndentation (textEditorData.Document).Length;
textEditorData.Insert (insertionPoint, "/// ");
return true;
}
//multi-line comments
} else if (stateTracker.Engine.IsInsideMultiLineComment) {
if (textEditorData.GetTextAt (line.Offset, line.Length).TrimStart ().StartsWith ("*", StringComparison.Ordinal))
return false;
textEditorData.EnsureCaretIsNotVirtual ();
string commentPrefix = string.Empty;
if (trimmedPreviousLine.StartsWith ("* ", StringComparison.Ordinal)) {
commentPrefix = "* ";
} else if (trimmedPreviousLine.StartsWith ("/**", StringComparison.Ordinal) || trimmedPreviousLine.StartsWith ("/*", StringComparison.Ordinal)) {
commentPrefix = " * ";
} else if (trimmedPreviousLine.StartsWith ("*", StringComparison.Ordinal)) {
commentPrefix = "*";
}
int indentSize = line.GetIndentation (textEditorData.Document).Length;
var insertedText = prevLine.GetIndentation (textEditorData.Document) + commentPrefix;
textEditorData.Replace (line.Offset, indentSize, insertedText);
textEditorData.Caret.Offset = line.Offset + insertedText.Length;
return true;
} else if (stateTracker.Engine.IsInsideStringLiteral) {
var lexer = new CSharpCompletionEngineBase.MiniLexer (textEditorData.Document.GetTextAt (0, prevLine.EndOffset));
lexer.Parse ();
if (!lexer.IsInString)
return false;
textEditorData.EnsureCaretIsNotVirtual ();
textEditorData.Insert (prevLine.Offset + prevLine.Length, "\" +");
int indentSize = line.GetIndentation (textEditorData.Document).Length;
var insertedText = prevLine.GetIndentation (textEditorData.Document) + (trimmedPreviousLine.StartsWith ("\"", StringComparison.Ordinal) ? "" : "\t") + "\"";
textEditorData.Replace (line.Offset, indentSize, insertedText);
return true;
}
}
return false;
}
/// <summary>
/// Builds a compileable stub file out of an entity.
/// </summary>
/// <returns>
/// A string representing the stub
/// </returns>
/// <param name='memberStartOffset'>
/// The offset where the member starts in the returned text.
/// </param>
static string BuildStub (MonoDevelop.Ide.Gui.Document data, CSharpCompletionTextEditorExtension.TypeSystemTreeSegment seg, int startOffset, int endOffset, out int memberStartOffset)
{
var pf = data.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (pf == null) {
memberStartOffset = 0;
return null;
}
var sb = new StringBuilder ();
int closingBrackets = 0;
// use the member start location to determine the using scope, because this information is in sync, the position in
// the file may have changed since last parse run (we have up 2 date locations from the type segment tree).
var scope = pf.GetUsingScope (seg.Entity.Region.Begin);
while (scope != null && !string.IsNullOrEmpty (scope.NamespaceName)) {
// Hack: some syntax errors lead to invalid namespace names.
if (scope.NamespaceName.EndsWith ("<invalid>", StringComparison.Ordinal)) {
scope = scope.Parent;
continue;
}
sb.Append ("namespace Stub {");
sb.Append (data.Editor.EolMarker);
closingBrackets++;
while (scope.Parent != null && scope.Parent.Region == scope.Region)
scope = scope.Parent;
scope = scope.Parent;
}
var parent = seg.Entity.DeclaringTypeDefinition;
while (parent != null) {
sb.Append ("class " + parent.Name + " {");
sb.Append (data.Editor.EolMarker);
closingBrackets++;
parent = parent.DeclaringTypeDefinition;
}
memberStartOffset = sb.Length;
var text = data.Editor.GetTextBetween (seg.Offset, endOffset);
sb.Append (text);
var lex = new CSharpCompletionEngineBase.MiniLexer (text);
lex.Parse (ch => {
if (lex.IsInString || lex.IsInChar || lex.IsInVerbatimString || lex.IsInSingleComment || lex.IsInMultiLineComment || lex.IsInPreprocessorDirective)
return;
if (ch =='{') {
closingBrackets++;
} else if (ch =='}') {
closingBrackets--;
}
});
// Insert at least caret column eol markers otherwise the reindent of the generated closing bracket
// could interfere with the current indentation.
var endLocation = data.Editor.OffsetToLocation (endOffset);
for (int i = 0; i <= endLocation.Column; i++) {
sb.Append (data.Editor.EolMarker);
}
sb.Append (data.Editor.EolMarker);
sb.Append (new string ('}', closingBrackets));
return sb.ToString ();
}
