| public OnTextInput ( Avalonia.Input.TextInputEventArgs e, int caretIndex, int line, int column ) : void | ||
| e | Avalonia.Input.TextInputEventArgs | |
| caretIndex | int | |
| line | int | |
| column | int | |
| return | void | |
public void OnTextInput(TextInputEventArgs e, int caretIndex, int line, int column)
{
if (e.Source == editor)
{
intellisenseJobRunner.InvokeAsync(() =>
{
if (e.Text.Length == 1)
{
char currentChar = e.Text[0];
if (completionAssistant.IsVisible)
{
if (caretIndex < completionAssistant.CurrentSignatureHelp.Offset)
{
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
completionAssistant.PopMethod();
}).Wait();
}
if (completionAssistant.CurrentSignatureHelp != null)
{
int index = 0;
int level = 0;
int offset = completionAssistant.CurrentSignatureHelp.Offset;
while (offset < caretIndex)
{
var curChar = '\0';
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
curChar = editor.TextDocument.GetCharAt(offset++);
}).Wait();
switch (curChar)
{
case ',':
if (level == 0)
{
index++;
}
break;
case '(':
level++;
break;
case ')':
level--;
break;
}
}
completionAssistant.SetParameterIndex(index);
}
}
if (currentChar == '(' && (completionAssistant.CurrentSignatureHelp == null || completionAssistant.CurrentSignatureHelp.Offset != editor.CaretIndex))
{
string currentWord = string.Empty;
char behindBehindCaretChar = '\0';
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
behindBehindCaretChar = editor.TextDocument.GetCharAt(caretIndex - 2);
}).Wait();
if (behindBehindCaretChar.IsWhiteSpace() && behindBehindCaretChar != '\0')
{
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
currentWord = editor.GetPreviousWordAtIndex(editor.CaretIndex - 1);
}).Wait();
}
else
{
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
currentWord = editor.GetWordAtIndex(editor.CaretIndex - 1);
}).Wait();
}
var signatureHelpTask = languageService.SignatureHelp(file, EditorModel.UnsavedFiles.FirstOrDefault(), EditorModel.UnsavedFiles.ToList(), line, column, editor.CaretIndex, currentWord);
signatureHelpTask.Wait();
var signatureHelp = signatureHelpTask.Result;
if (signatureHelp != null)
{
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
completionAssistant.PushMethod(signatureHelp);
}).Wait();
}
}
else if (currentChar == ')')
{
Dispatcher.UIThread.InvokeTaskAsync(() =>
{
completionAssistant.PopMethod();
}).Wait();
}
if (IsCompletionChar(currentChar))
{
DoComplete(true);
}
if (currentChar.IsWhiteSpace() || IsSearchChar(currentChar))
{
SetCursor(caretIndex, line, column, EditorModel.UnsavedFiles.ToList(), false);
}
if (IsTriggerChar(currentChar, intellisenseControl.IsVisible) || IsLanguageSpecificTriggerChar(currentChar))
{
if (!intellisenseControl.IsVisible)
{
OpenIntellisense(currentChar, caretIndex);
}
else if (caretIndex > intellisenseStartedAt)
{
UpdateFilter(caretIndex);
}
else
{
CloseIntellisense();
SetCursor(caretIndex, line, column, EditorModel.UnsavedFiles.ToList(), false);
}
isProcessingKey = intellisenseControl.IsVisible;
}
}
});
}
}
public EditorViewModel(EditorModel model) : base(model)
{
disposables = new CompositeDisposable();
highlightingData = new ObservableCollection <OffsetSyntaxHighlightingData>();
BeforeTextChangedCommand = ReactiveCommand.Create();
disposables.Add(BeforeTextChangedCommand.Subscribe(model.OnBeforeTextChanged));
TextChangedCommand = ReactiveCommand.Create();
disposables.Add(TextChangedCommand.Subscribe(model.OnTextChanged));
SaveCommand = ReactiveCommand.Create();
disposables.Add(SaveCommand.Subscribe(param => Save()));
disposables.Add(CloseCommand.Subscribe(_ =>
{
Model.ProjectFile.FileModifiedExternally -= ProjectFile_FileModifiedExternally;
Model.Editor.CaretChangedByPointerClick -= Editor_CaretChangedByPointerClick;
Save();
Model.ShutdownBackgroundWorkers();
Model.UnRegisterLanguageService();
intellisenseManager?.Dispose();
intellisenseManager = null;
Diagnostics?.Clear();
ShellViewModel.Instance.InvalidateErrors();
Model.Dispose();
Intellisense.Dispose();
disposables.Dispose();
Model.TextDocument = null;
}));
AddWatchCommand = ReactiveCommand.Create();
disposables.Add(AddWatchCommand.Subscribe(_ => { IoC.Get <IWatchList>()?.AddWatch(WordAtCaret); }));
tabCharacter = " ";
model.DocumentLoaded += (sender, e) =>
{
model.ProjectFile.FileModifiedExternally -= ProjectFile_FileModifiedExternally;
Model.Editor.CaretChangedByPointerClick -= Editor_CaretChangedByPointerClick;
foreach (var bgRenderer in languageServiceBackgroundRenderers)
{
BackgroundRenderers.Remove(bgRenderer);
}
languageServiceBackgroundRenderers.Clear();
foreach (var transformer in languageServiceDocumentLineTransformers)
{
DocumentLineTransformers.Remove(transformer);
}
languageServiceDocumentLineTransformers.Clear();
if (model.LanguageService != null)
{
languageServiceBackgroundRenderers.AddRange(model.LanguageService.GetBackgroundRenderers(model.ProjectFile));
foreach (var bgRenderer in languageServiceBackgroundRenderers)
{
BackgroundRenderers.Add(bgRenderer);
}
languageServiceDocumentLineTransformers.AddRange(
model.LanguageService.GetDocumentLineTransformers(model.ProjectFile));
foreach (var textTransformer in languageServiceDocumentLineTransformers)
{
DocumentLineTransformers.Add(textTransformer);
}
intellisenseManager = new IntellisenseManager(Model.Editor, Intellisense, Intellisense.CompletionAssistant, model.LanguageService, model.ProjectFile);
EventHandler <KeyEventArgs> tunneledKeyUpHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnKeyUp(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
EventHandler <KeyEventArgs> tunneledKeyDownHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnKeyDown(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
EventHandler <TextInputEventArgs> tunneledTextInputHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnTextInput(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
Model.Editor.CaretChangedByPointerClick += Editor_CaretChangedByPointerClick;
disposables.Add(Model.Editor.AddHandler(InputElement.KeyDownEvent, tunneledKeyDownHandler, RoutingStrategies.Tunnel));
disposables.Add(Model.Editor.AddHandler(InputElement.KeyUpEvent, tunneledKeyUpHandler, RoutingStrategies.Tunnel));
disposables.Add(Model.Editor.AddHandler(InputElement.TextInputEvent, tunneledTextInputHandler, RoutingStrategies.Bubble));
}
model.CodeAnalysisCompleted += (s, ee) =>
{
Diagnostics = model.CodeAnalysisResults.Diagnostics;
HighlightingData =
new ObservableCollection <OffsetSyntaxHighlightingData>(model.CodeAnalysisResults.SyntaxHighlightingData);
IndexItems = new ObservableCollection <IndexEntry>(model.CodeAnalysisResults.IndexItems);
selectedIndexEntry = IndexItems.FirstOrDefault();
this.RaisePropertyChanged(nameof(SelectedIndexEntry));
ShellViewModel.Instance.InvalidateErrors();
};
model.ProjectFile.FileModifiedExternally += ProjectFile_FileModifiedExternally;
TextDocument = model.TextDocument;
Title = Model.ProjectFile.Name;
};
model.TextChanged += (sender, e) =>
{
if (ShellViewModel.Instance.DocumentTabs.TemporaryDocument == this)
{
Dock = Dock.Left;
ShellViewModel.Instance.DocumentTabs.TemporaryDocument = null;
}
IsDirty = model.IsDirty;
};
intellisense = new IntellisenseViewModel(model, this);
documentLineTransformers = new ObservableCollection <IDocumentLineTransformer>();
backgroundRenderers = new ObservableCollection <IBackgroundRenderer>();
backgroundRenderers.Add(new SelectedLineBackgroundRenderer());
DebugLineHighlighter = new SelectedDebugLineBackgroundRenderer();
backgroundRenderers.Add(DebugLineHighlighter);
backgroundRenderers.Add(new ColumnLimitBackgroundRenderer());
wordAtCaretHighlighter = new SelectedWordBackgroundRenderer();
backgroundRenderers.Add(wordAtCaretHighlighter);
backgroundRenderers.Add(new SelectionBackgroundRenderer());
margins = new ObservableCollection <TextViewMargin>();
Dock = Dock.Right;
}