public OverrideEqualsGetHashCodeMethodsDialog(InsertionContext context, ITextEditor editor, ITextAnchor startAnchor, ITextAnchor endAnchor,
ITextAnchor insertionPosition, IClass selectedClass, IMethod selectedMethod, string baseCall)
: base(context, editor, insertionPosition)
{
if (selectedClass == null)
throw new ArgumentNullException("selectedClass");
InitializeComponent();
this.selectedClass = selectedClass;
this.startAnchor = startAnchor;
this.insertionEndAnchor = endAnchor;
this.selectedMethod = selectedMethod;
this.baseCall = baseCall;
addIEquatable.Content = string.Format(StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddInterface}"),
"IEquatable<" + selectedClass.Name + ">");
string otherMethod = selectedMethod.Name == "Equals" ? "GetHashCode" : "Equals";
addOtherMethod.Content = StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddOtherMethod}", new StringTagPair("otherMethod", otherMethod));
addIEquatable.IsEnabled = !selectedClass.BaseTypes.Any(
type => {
if (!type.IsGenericReturnType)
return false;
var genericType = type.CastToGenericReturnType();
var boundTo = genericType.TypeParameter.BoundTo;
if (boundTo == null)
return false;
return boundTo.Name == selectedClass.Name;
}
);
}
protected void OpenAtPosition(ITextEditor editor, int line, int column, bool openAtWordStart)
{
var editorUIService = editor == null ? null : editor.GetService(typeof(IEditorUIService)) as IEditorUIService;
if (editorUIService != null) {
var document = editor.Document;
int offset = document.PositionToOffset(line, column);
if (openAtWordStart) {
int wordStart = document.FindPrevWordStart(offset);
if (wordStart != -1) {
var wordStartLocation = document.OffsetToPosition(wordStart);
line = wordStartLocation.Line;
column = wordStartLocation.Column;
}
}
this.Placement = PlacementMode.Absolute;
try
{
var caretScreenPos = editorUIService.GetScreenPosition(line, column);
this.HorizontalOffset = caretScreenPos.X;
this.VerticalOffset = caretScreenPos.Y;
}
catch
{
this.Placement = PlacementMode.MousePoint;
}
} else {
// if no editor information, open at mouse positions
this.Placement = PlacementMode.MousePoint;
}
this.Open();
}
public override void IndentLines(ITextEditor editor, int beginLine, int endLine)
{
DocumentAccessor acc = new DocumentAccessor(editor.Document, beginLine, endLine);
CSharpIndentationStrategy indentStrategy = new CSharpIndentationStrategy();
indentStrategy.IndentationString = editor.Options.IndentationString;
indentStrategy.Indent(acc, true);
}
protected override void RunImpl(ITextEditor editor, int offset, ResolveResult symbol)
{
if (symbol == null)
return;
FilePosition pos = symbol.GetDefinitionPosition();
if (pos.IsEmpty) {
IEntity entity;
if (symbol is MemberResolveResult) {
entity = ((MemberResolveResult)symbol).ResolvedMember;
} else if (symbol is TypeResolveResult) {
entity = ((TypeResolveResult)symbol).ResolvedClass;
} else {
entity = null;
}
if (entity != null) {
NavigationService.NavigateTo(entity);
}
} else {
try {
if (pos.Position.IsEmpty)
FileService.OpenFile(pos.FileName);
else
FileService.JumpToFilePosition(pos.FileName, pos.Line, pos.Column);
} catch (Exception ex) {
MessageService.ShowException(ex, "Error jumping to '" + pos.FileName + "'.");
}
}
}
public SharpDevelopCompletionWindow(ITextEditor editor, TextArea textArea, ICompletionItemList itemList) : base(textArea)
{
if (editor == null)
throw new ArgumentNullException("editor");
if (itemList == null)
throw new ArgumentNullException("itemList");
if (!itemList.ContainsAllAvailableItems) {
// If more items are available (Ctrl+Space wasn't pressed), show this hint
this.EmptyText = StringParser.Parse("${res:ICSharpCode.AvalonEdit.AddIn.SharpDevelopCompletionWindow.EmptyText}");
}
InitializeComponent();
this.Editor = editor;
this.itemList = itemList;
ICompletionItem suggestedItem = itemList.SuggestedItem;
foreach (ICompletionItem item in itemList.Items) {
ICompletionData adapter = new CodeCompletionDataAdapter(this, item);
this.CompletionList.CompletionData.Add(adapter);
if (item == suggestedItem)
this.CompletionList.SelectedItem = adapter;
}
this.StartOffset -= itemList.PreselectionLength;
this.EndOffset += itemList.PostselectionLength;
}
protected bool ProvideContextCompletion(ITextEditor editor, IReturnType expected, char charTyped)
{
if (expected == null) return false;
IClass c = expected.GetUnderlyingClass();
if (c == null) return false;
if (c.ClassType == ClassType.Enum) {
CtrlSpaceCompletionItemProvider cdp = new NRefactoryCtrlSpaceCompletionItemProvider(languageProperties);
var ctrlSpaceList = cdp.GenerateCompletionList(editor);
if (ctrlSpaceList == null) return false;
ContextCompletionItemList contextList = new ContextCompletionItemList();
contextList.Items.AddRange(ctrlSpaceList.Items);
contextList.activationKey = charTyped;
foreach (CodeCompletionItem item in contextList.Items.OfType<CodeCompletionItem>()) {
IClass itemClass = item.Entity as IClass;
if (itemClass != null && c.FullyQualifiedName == itemClass.FullyQualifiedName && c.TypeParameters.Count == itemClass.TypeParameters.Count) {
contextList.SuggestedItem = item;
break;
}
}
if (contextList.SuggestedItem != null) {
if (charTyped != ' ') contextList.InsertSpace = true;
editor.ShowCompletionWindow(contextList);
return true;
}
}
return false;
}
public EditorScript(ITextEditor editor, SDRefactoringContext context, CSharpFormattingOptions formattingOptions)
: base(editor.Document, formattingOptions, context.TextEditorOptions)
{
this.editor = editor;
this.context = context;
this.textSegmentCollection = new TextSegmentCollection<TextSegment>((TextDocument)editor.Document);
}
public void Attach(ITextEditor editor)
{
this.editor = editor;
inspectionManager = new IssueManager(editor);
codeManipulation = new CodeManipulation(editor);
renderer = new CaretReferenceHighlightRenderer(editor);
// Patch editor options (indentation) to project-specific settings
if (!editor.ContextActionProviders.IsReadOnly) {
contextActionProviders = AddInTree.BuildItems<IContextActionProvider>("/SharpDevelop/ViewContent/TextEditor/C#/ContextActions", null);
editor.ContextActionProviders.AddRange(contextActionProviders);
}
// Create instance of options adapter and register it as service
var formattingPolicy = CSharpFormattingPolicies.Instance.GetProjectOptions(
SD.ProjectService.FindProjectContainingFile(editor.FileName));
options = new CodeEditorFormattingOptionsAdapter(editor.Options, formattingPolicy.OptionsContainer);
var textEditor = editor.GetService<TextEditor>();
if (textEditor != null) {
var textViewServices = textEditor.TextArea.TextView.Services;
// Unregister any previous ITextEditorOptions instance from editor, if existing, register our impl.
textViewServices.RemoveService(typeof(ITextEditorOptions));
textViewServices.AddService(typeof(ITextEditorOptions), options);
// Set TextEditor's options to same object
originalEditorOptions = textEditor.Options;
textEditor.Options = options;
}
}
public OverrideEqualsGetHashCodeMethodsDialog(InsertionContext context, ITextEditor editor, ITextAnchor endAnchor,
ITextAnchor insertionPosition, ITypeDefinition selectedClass, IMethod selectedMethod, AstNode baseCallNode)
: base(context, editor, insertionPosition)
{
if (selectedClass == null)
throw new ArgumentNullException("selectedClass");
InitializeComponent();
this.selectedClass = selectedClass;
this.insertionEndAnchor = endAnchor;
this.selectedMethod = selectedMethod;
this.baseCallNode = baseCallNode;
addIEquatable.Content = string.Format(StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddInterface}"),
"IEquatable<" + selectedClass.Name + ">");
string otherMethod = selectedMethod.Name == "Equals" ? "GetHashCode" : "Equals";
addOtherMethod.Content = StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddOtherMethod}", new StringTagPair("otherMethod", otherMethod));
addIEquatable.IsEnabled = !selectedClass.GetAllBaseTypes().Any(
type => {
if (!type.IsParameterized || (type.TypeParameterCount != 1))
return false;
if (type.FullName != "System.IEquatable")
return false;
return type.TypeArguments.First().FullName == selectedClass.FullName;
}
);
}
public ToolTipRequestEventArgs(ITextEditor editor)
{
if (editor == null)
throw new ArgumentNullException("editor");
this.Editor = editor;
this.InDocument = true;
}
public override void Attach(ITextEditor editor)
{
base.Attach(editor);
// try to access the ICSharpCode.AvalonEdit.Rendering.TextView
// of this ITextEditor
this.textView = editor.GetService(typeof(TextView)) as TextView;
// if editor is not an AvalonEdit.TextEditor
// GetService returns null
if (textView != null) {
if (SD.Workbench != null) {
// if (XamlBindingOptions.UseAdvancedHighlighting) {
// colorizer = new XamlColorizer(editor, textView);
// // attach the colorizer
// textView.LineTransformers.Add(colorizer);
// }
// add the XamlOutlineContentHost, which manages the tree view
contentHost = new XamlOutlineContentHost(editor);
textView.Services.AddService(typeof(IOutlineContentHost), contentHost);
}
// add ILanguageBinding
textView.Services.AddService(typeof(XamlTextEditorExtension), this);
}
SD.ParserService.ParseInformationUpdated += ParseInformationUpdated;
}
public ICSharpCodeCoreTagCompletionItemList(ITextEditor editor)
: base()
{
var item = new DefaultCompletionItem("{res") { Image = ClassBrowserIconService.Keyword };
this.Items.Add(item);
this.SuggestedItem = item;
}
protected override bool Refactor(ITextEditor editor, XDocument document)
{
if (editor.SelectionLength == 0) {
MessageService.ShowError("Nothing selected!");
return false;
}
Location startLoc = editor.Document.OffsetToPosition(editor.SelectionStart);
Location endLoc = editor.Document.OffsetToPosition(editor.SelectionStart + editor.SelectionLength);
var selectedItems = (from item in document.Root.Descendants()
where item.IsInRange(startLoc, endLoc) select item).ToList();
if (selectedItems.Any()) {
var parent = selectedItems.First().Parent;
currentWpfNamespace = parent.GetCurrentNamespaces()
.First(i => CompletionDataHelper.WpfXamlNamespaces.Contains(i));
var items = selectedItems.Where(i => i.Parent == parent);
return GroupInto(parent, items);
}
return false;
}
/// <inheritdoc/>
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
if (editor == null)
throw new ArgumentNullException("textEditor");
ExpressionResult expression = GetExpression(editor);
return GenerateCompletionListForExpression(editor, expression);
}
public override void IndentLine(ITextEditor editor, IDocumentLine line)
{
LineIndenter indenter = CreateLineIndenter(editor, line);
if (!indenter.Indent()) {
base.IndentLine(editor, line);
}
}
public void InitializeOpenedInsightWindow(ITextEditor editor, IInsightWindow insightWindow)
{
EventHandler<TextChangeEventArgs> onDocumentChanged = delegate {
// whenever the document is changed, recalculate EndOffset
var remainingDocument = editor.Document.CreateReader(insightWindow.StartOffset, editor.Document.TextLength - insightWindow.StartOffset);
using (ILexer lexer = ParserFactory.CreateLexer(language, remainingDocument)) {
lexer.SetInitialLocation(editor.Document.OffsetToPosition(insightWindow.StartOffset));
Token token;
int bracketCount = 0;
while ((token = lexer.NextToken()) != null && token.Kind != eofToken) {
if (token.Kind == openParensToken || token.Kind == openBracketToken || token.Kind == openBracketToken) {
bracketCount++;
} else if (token.Kind == closeParensToken || token.Kind == closeBracketToken || token.Kind == closeBracesToken) {
bracketCount--;
if (bracketCount <= 0) {
MarkInsightWindowEndOffset(insightWindow, editor, token.Location);
break;
}
} else if (token.Kind == statementEndToken) {
MarkInsightWindowEndOffset(insightWindow, editor, token.Location);
break;
}
}
}
};
insightWindow.DocumentChanged += onDocumentChanged;
insightWindow.SelectedItemChanged += delegate { HighlightParameter(insightWindow, highlightedParameter); };
onDocumentChanged(null, null);
}
public FoldingManagerAdapter(ITextEditor textEditor)
{
AvalonEditTextEditorAdapter adaptor = textEditor as AvalonEditTextEditorAdapter;
if (adaptor != null) {
this.foldingManager = FoldingManager.Install(adaptor.TextEditor.TextArea);
}
}
public void CreatePins(ITextEditor editor)
{
// load pins
var pins = BookmarkManager.Bookmarks.FindAll(
b => b is PinBookmark && b.FileName == editor.FileName);
foreach (var bookmark in pins) {
var pin = (PinBookmark)bookmark;
pin.Popup = new PinDebuggerControl();
pin.Popup.Mark = pin;
var nodes = new ObservableCollection<ITreeNode>();
foreach (var tuple in pin.SavedNodes) {
string imageName = !string.IsNullOrEmpty(tuple.Item1) ? tuple.Item1 : "Icons.16x16.Field";
var node = new Debugger.AddIn.TreeModel.SavedTreeNode(
new ResourceServiceImage(imageName),
tuple.Item2,
tuple.Item3);
node.ImageName = imageName;
nodes.Add(node);
}
pin.SavedNodes.Clear();
pin.Popup.ItemsSource = nodes;
pin.Nodes = nodes;
pinLayer.Pin((PinDebuggerControl)pin.Popup);
}
}
public void ClosePins(ITextEditor editor)
{
// save pins
var pins = BookmarkManager.Bookmarks.FindAll(
b => b is PinBookmark && b.FileName == editor.FileName);
foreach (var bookmark in pins) {
var pin = (PinBookmark)bookmark;
if (!pin.PinPosition.HasValue)
pin.PinPosition = pin.Popup.Location;
// nodes
if (pin.SavedNodes == null)
pin.SavedNodes = new System.Collections.Generic.List<Tuple<string, string, string>>();
foreach (var node in pin.Nodes) {
pin.SavedNodes.Add(
new Tuple<string, string, string>(
"Icons.16x16.Field",
node.FullName,
node.Text));
}
pinLayer.Unpin((PinDebuggerControl)pin.Popup);
pin.Popup = null;
}
}
public IInsightItem[] ProvideInsight(ITextEditor editor)
{
if (editor == null)
throw new ArgumentNullException("editor");
IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(editor.FileName);
if (expressionFinder == null) {
return null;
}
IDocument document = editor.Document;
int useOffset = (this.LookupOffset < 0) ? editor.Caret.Offset : this.LookupOffset;
ExpressionResult expressionResult = expressionFinder.FindExpression(document.Text, useOffset);
if (expressionResult.Expression == null) // expression is null when cursor is in string/comment
return null;
if (LoggingService.IsDebugEnabled) {
if (expressionResult.Context == ExpressionContext.Default)
LoggingService.DebugFormatted("ShowInsight for >>{0}<<", expressionResult.Expression);
else
LoggingService.DebugFormatted("ShowInsight for >>{0}<<, context={1}", expressionResult.Expression, expressionResult.Context);
}
var position = document.OffsetToPosition(useOffset);
ResolveResult rr = ParserService.Resolve(expressionResult, position.Line, position.Column, editor.FileName, document.Text);
return ProvideInsight(expressionResult, rr);
}
void ITextEditorExtension.Attach(ITextEditor editor)
{
_outlineContent = new ModuleOutlineControl(editor);
_textView = editor.GetService(typeof(TextView)) as TextView;
_textView.Services.AddService(typeof(IOutlineContentHost), _outlineContent);
}
public SendToScriptingConsoleCommand(IScriptingWorkbench workbench)
{
this.workbench = workbench;
textEditorView = new ScriptingTextEditorViewContent(workbench);
activeTextEditor = textEditorView.TextEditor;
}
internal ModuleOutlineControl(ITextEditor textEditor)
: this()
{
_textEditor = textEditor;
SD.ParserService.ParseInformationUpdated += ParserService_ParseInformationUpdated;
}
protected override bool Refactor(ITextEditor editor, XDocument document)
{
Location startLoc = editor.Document.OffsetToPosition(editor.SelectionStart);
Location endLoc = editor.Document.OffsetToPosition(editor.SelectionStart + editor.SelectionLength);
XName[] names = CompletionDataHelper.WpfXamlNamespaces.Select(item => XName.Get("Grid", item)).ToArray();
XElement selectedItem = document.Root.Descendants()
.FirstOrDefault(item => item.IsInRange(startLoc, endLoc) && names.Any(ns => ns == item.Name))
?? document.Root.Elements().FirstOrDefault(i => names.Any(ns => ns == i.Name));
if (selectedItem == null) {
MessageService.ShowError("Please select a Grid!");
return false;
}
EditGridColumnsAndRowsDialog dialog = new EditGridColumnsAndRowsDialog(selectedItem);
dialog.Owner = WorkbenchSingleton.MainWindow;
if (dialog.ShowDialog() == true) {
selectedItem.ReplaceWith(dialog.ConstructedTree);
return true;
}
return false;
}
public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
{
if (this.CompletionPossible(editor, ch)) {
ResourceResolveResult result = ResourceResolverService.Resolve(editor, ch);
if (result != null) {
IResourceFileContent content;
if ((content = result.ResourceFileContent) != null) {
// If the resolved resource set is the local ICSharpCode.Core resource set
// (this may happen through the ICSharpCodeCoreNRefactoryResourceResolver),
// we will have to merge in the host resource set (if available)
// for the code completion window.
if (result.ResourceSetReference.ResourceSetName == ICSharpCodeCoreResourceResolver.ICSharpCodeCoreLocalResourceSetName) {
IResourceFileContent hostContent = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent;
if (hostContent != null) {
content = new MergedResourceFileContent(content, new IResourceFileContent[] { hostContent });
}
}
editor.ShowCompletionWindow(new ResourceCodeCompletionItemList(content, this.OutputVisitor, result.CallingClass != null ? result.CallingClass.Name+"." : null));
return CodeCompletionKeyPressResult.Completed;
}
}
}
return CodeCompletionKeyPressResult.None;
}
/// <summary>
/// Default implementation for single line comments.
/// </summary>
protected void SurroundSelectionWithSingleLineComment(ITextEditor editor, string comment)
{
IDocument document = editor.Document;
using (document.OpenUndoGroup()) {
TextLocation startPosition = document.GetLocation(editor.SelectionStart);
TextLocation endPosition = document.GetLocation(editor.SelectionStart + editor.SelectionLength);
// endLine is one above endPosition if no characters are selected on the last line (e.g. line selection from the margin)
int endLine = (endPosition.Column == 1 && endPosition.Line > startPosition.Line) ? endPosition.Line - 1 : endPosition.Line;
List<IDocumentLine> lines = new List<IDocumentLine>();
bool removeComment = true;
for (int i = startPosition.Line; i <= endLine; i++) {
lines.Add(editor.Document.GetLineByNumber(i));
if (!document.GetText(lines[i - startPosition.Line]).Trim().StartsWith(comment, StringComparison.Ordinal))
removeComment = false;
}
foreach (IDocumentLine line in lines) {
if (removeComment) {
document.Remove(line.Offset + document.GetText(line).IndexOf(comment, StringComparison.Ordinal), comment.Length);
} else {
document.Insert(line.Offset, comment, AnchorMovementType.BeforeInsertion);
}
}
}
}
public override void IndentLines(ITextEditor editor, int beginLine, int endLine)
{
//DocumentAccessor acc = new DocumentAccessor(editor.Document, beginLine, endLine);
//CSharpIndentationStrategy indentStrategy = new CSharpIndentationStrategy();
//indentStrategy.IndentationString = editor.Options.IndentationString;
//indentStrategy.Indent(acc, true);
SharpLua.Visitors.NonModifiedAstBeautifier b = null;
try
{
Lexer l = new Lexer();
Parser p = new Parser(l.Lex(editor.Document.Text));
SharpLua.Ast.Chunk c = p.Parse();
b = new SharpLua.Visitors.NonModifiedAstBeautifier();
//SharpLua.Visitors.ExactReconstruction b = new SharpLua.Visitors.ExactReconstruction();
b.options.Tab = editor.Options.IndentationString;
b.options.TabsToSpaces = editor.Options.ConvertTabsToSpaces;
int off = editor.Caret.Offset;
//editor.Document.Text = b.Reconstruct(c);
editor.Document.Text = b.Beautify(c);
editor.Caret.Offset = off >= editor.Document.TextLength ? 0 : off;
}
catch (LuaSourceException ex)
{
LoggingService.Warn("Error parsing document: " + System.IO.Path.GetFileName(ex.GenerateMessage(editor.FileName)));
}
catch (System.Exception ex)
{
LoggingService.Error("Error formatting document:", ex);
MessageBox.Show(b.index.ToString() + " "+ b.tok.Count);
MessageBox.Show("Error formatting Lua script: " + ex.ToString() + "\r\n\r\nPlease report this to the SharpLua GitHub page so it can get fixed");
}
}
/// <summary>
/// Formats the specified part of the document.
/// </summary>
public static void Format(ITextEditor editor, int offset, int length, CSharpFormattingOptions options)
{
var formatter = new CSharpFormatter(options, editor.ToEditorOptions());
formatter.AddFormattingRegion(new DomRegion(editor.Document.GetLocation(offset), editor.Document.GetLocation(offset + length)));
var changes = formatter.AnalyzeFormatting(editor.Document, SyntaxTree.Parse(editor.Document));
changes.ApplyChanges(offset, length);
}
public AutoCompleteTextBox()
{
object tmp;
this.editorAdapter = SD.EditorControlService.CreateEditor(out tmp);
this.editor = (TextEditor)tmp;
this.editor.Background = Brushes.Transparent;
this.editor.ClearValue(TextEditor.FontFamilyProperty);
this.editor.ClearValue(TextEditor.FontSizeProperty);
this.editor.ShowLineNumbers = false;
this.editor.WordWrap = false;
this.editor.HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden;
this.editor.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
this.editor.TextArea.GotKeyboardFocus += delegate {
this.Background = Brushes.White;
this.Foreground = Brushes.Black;
};
this.editor.TextArea.LostKeyboardFocus += delegate {
this.Background = Brushes.Transparent;
this.ClearValue(ForegroundProperty);
this.Text = this.editor.Text;
this.editorAdapter.ClearSelection();
};
this.editor.TextArea.PreviewKeyDown += editor_TextArea_PreviewKeyDown;
this.editor.TextArea.TextEntered += editor_TextArea_TextEntered;
this.Content = this.editor.TextArea;
HorizontalContentAlignment = HorizontalAlignment.Stretch;
VerticalContentAlignment = VerticalAlignment.Stretch;
}
protected override void Run(ITextEditor editor, IBookmarkMargin bookmarkMargin)
{
int lineNumber = editor.Caret.Line;
if (!SD.BookmarkManager.RemoveBookmarkAt(editor.FileName, lineNumber, b => b is Bookmark)) {
SD.BookmarkManager.AddMark(new Bookmark(), editor.Document, lineNumber);
}
}
public static IEnumerable <AddUsingAction> GetAddUsingActions(UnknownConstructorCallResolveResult rr, ITextEditor textArea)
{
return(GetAddUsingActionsForUnknownClass(rr.CallingClass, rr.TypeName, textArea));
}
public virtual void FormatLine(ITextEditor editor, char charTyped)
{
}
public static BlockCommentRegion FindSelectedCommentRegion(ITextEditor editor, string commentStart, string commentEnd)
{
IDocument document = editor.Document;
if (document.TextLength == 0)
{
return(null);
}
// Find start of comment in selected text.
int commentEndOffset = -1;
string selectedText = editor.SelectedText;
int commentStartOffset = selectedText.IndexOf(commentStart);
if (commentStartOffset >= 0)
{
commentStartOffset += editor.SelectionStart;
}
// Find end of comment in selected text.
if (commentStartOffset >= 0)
{
commentEndOffset = selectedText.IndexOf(commentEnd, commentStartOffset + commentStart.Length - editor.SelectionStart);
}
else
{
commentEndOffset = selectedText.IndexOf(commentEnd);
}
if (commentEndOffset >= 0)
{
commentEndOffset += editor.SelectionStart;
}
// Find start of comment before or partially inside the
// selected text.
int commentEndBeforeStartOffset = -1;
if (commentStartOffset == -1)
{
int offset = editor.SelectionStart + editor.SelectionLength + commentStart.Length - 1;
if (offset > document.TextLength)
{
offset = document.TextLength;
}
string text = document.GetText(0, offset);
commentStartOffset = text.LastIndexOf(commentStart);
if (commentStartOffset >= 0)
{
// Find end of comment before comment start.
commentEndBeforeStartOffset = text.IndexOf(commentEnd, commentStartOffset, editor.SelectionStart - commentStartOffset);
if (commentEndBeforeStartOffset > commentStartOffset)
{
commentStartOffset = -1;
}
}
}
// Find end of comment after or partially after the
// selected text.
if (commentEndOffset == -1)
{
int offset = editor.SelectionStart + 1 - commentEnd.Length;
if (offset < 0)
{
offset = editor.SelectionStart;
}
string text = document.GetText(offset, document.TextLength - offset);
commentEndOffset = text.IndexOf(commentEnd);
if (commentEndOffset >= 0)
{
commentEndOffset += offset;
}
}
if (commentStartOffset != -1 && commentEndOffset != -1)
{
return(new BlockCommentRegion(commentStart, commentEnd, commentStartOffset, commentEndOffset));
}
return(null);
}
public virtual bool CtrlSpace(ITextEditor editor)
{
return(false);
}
public virtual bool HandleKeyword(ITextEditor editor, string word)
{
// DefaultCodeCompletionBinding does not support Keyword handling, but this
// method can be overridden
return(false);
}
public virtual CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
{
switch (ch)
{
case '(':
if (enableMethodInsight && CodeCompletionOptions.InsightEnabled)
{
IInsightWindow insightWindow = editor.ShowInsightWindow(new MethodInsightProvider().ProvideInsight(editor));
if (insightWindow != null && insightHandler != null)
{
insightHandler.InitializeOpenedInsightWindow(editor, insightWindow);
insightHandler.HighlightParameter(insightWindow, -1); // disable highlighting
}
return(CodeCompletionKeyPressResult.Completed);
}
break;
case '[':
if (enableIndexerInsight && CodeCompletionOptions.InsightEnabled)
{
IInsightWindow insightWindow = editor.ShowInsightWindow(new IndexerInsightProvider().ProvideInsight(editor));
if (insightWindow != null && insightHandler != null)
{
insightHandler.InitializeOpenedInsightWindow(editor, insightWindow);
}
return(CodeCompletionKeyPressResult.Completed);
}
break;
case '<':
if (enableXmlCommentCompletion)
{
new CommentCompletionItemProvider().ShowCompletion(editor);
return(CodeCompletionKeyPressResult.Completed);
}
break;
case '.':
if (enableDotCompletion)
{
new DotCodeCompletionItemProvider().ShowCompletion(editor);
return(CodeCompletionKeyPressResult.Completed);
}
break;
case ' ':
if (CodeCompletionOptions.KeywordCompletionEnabled)
{
string word = editor.GetWordBeforeCaret();
if (!string.IsNullOrEmpty(word))
{
if (HandleKeyword(editor, word))
{
return(CodeCompletionKeyPressResult.Completed);
}
}
}
break;
}
return(CodeCompletionKeyPressResult.None);
}
static IEnumerable <AddUsingAction> GetAddUsingActionsForUnknownClass(IClass callingClass, string unknownClassName, ITextEditor editor)
{
if (callingClass == null)
{
yield break;
}
IProjectContent pc = callingClass.ProjectContent;
if (!pc.Language.RefactoringProvider.IsEnabledForFile(callingClass.CompilationUnit.FileName))
{
yield break;
}
List <IClass> searchResults = new List <IClass>();
SearchAllClassesWithName(searchResults, pc, unknownClassName, pc.Language);
foreach (IProjectContent rpc in pc.ReferencedContents)
{
SearchAllClassesWithName(searchResults, rpc, unknownClassName, pc.Language);
}
foreach (IClass c in searchResults)
{
string newNamespace = c.Namespace;
yield return(new AddUsingAction(callingClass.CompilationUnit, editor, newNamespace));
}
}
public static IEnumerable <AddUsingAction> GetAddUsingActions(ResolveResult symbol, ITextEditor editor)
{
if (symbol is UnknownIdentifierResolveResult)
{
return(GetAddUsingActions((UnknownIdentifierResolveResult)symbol, editor));
}
else if (symbol is UnknownConstructorCallResolveResult)
{
return(GetAddUsingActions((UnknownConstructorCallResolveResult)symbol, editor));
}
return(new AddUsingAction[0]);
}
/// <summary> /// Generates the completion list. /// </summary> public abstract ICompletionItemList GenerateCompletionList(ITextEditor editor);
public static IEnumerable <AddUsingAction> GetAddUsingActions(UnknownIdentifierResolveResult rr, ITextEditor textArea)
{
return(GetAddUsingActionsForUnknownClass(rr.CallingClass, rr.Identifier, textArea));
}
public override void ShowCompletion(ITextEditor editor)
{
TextEditorPassedToShowCompletion = editor;
}
public virtual ExpressionResult GetExpression(ITextEditor editor)
{
return(GetExpressionFromOffset(editor, editor.Caret.Offset));
}
public void Attach(ITextEditor editor)
{
Attach(textEditorFactory.CreateTextEditor(editor));
}
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
throw new NotImplementedException();
}
/// <summary>
/// Inserts code at the line before target AST node.
/// </summary>
public static void InsertCodeBefore(this ITextEditor editor, AbstractNode target, AbstractNode insert)
{
InsertCode(editor, target, insert, editor.Document.GetPreviousLineEndOffset(target.StartLocation), false);
}
public static void ClearSelection(this ITextEditor editor)
{
editor.Select(editor.Document.PositionToOffset(editor.Caret.Position), 0);
}
private (ISegment whitespace, int offset, char character) GetPreviousBracketInfo(ITextEditor editor, int offset)
{
if (offset >= editor.Document.TextLength)
{
offset = editor.Document.TextLength - 1;
}
if (offset >= 0)
{
var location = editor.Document.GetLocation(offset);
var line = editor.Document.Lines[location.Line];
var previousBracket = editor.Document.GetLastCharMatching(c => c == '{' || c == '}', line.Offset, 0);
if (previousBracket.index != -1)
{
var previousBracketLocation = editor.Document.GetLocation(previousBracket.index);
var previousBracketLine = editor.Document.Lines[previousBracketLocation.Line];
return(editor.Document.GetWhitespaceAfter(previousBracketLine.Offset), previousBracket.index, previousBracket.character);
}
}
return(null, -1, '\0');
}
protected abstract void Run(ITextEditor editor, IBookmarkMargin bookmarkMargin);
public bool AfterTextInput(ITextEditor editor, string inputText)
{
if (inputText == "\n")
{
var previousBracketInfo = GetPreviousBracketInfo(editor, editor.Offset - 1);
if (previousBracketInfo.whitespace != null)
{
Indent(editor, editor.Line, previousBracketInfo.whitespace, previousBracketInfo.character);
}
ConditionalIndent(editor, true);
}
else if (inputText == "{" || inputText == "}" || inputText == ";")
{
var prevLine = editor.PreviousLine();
if (prevLine != null)
{
var lastCharInfo = editor.Document.GetLastNonWhiteSpaceCharBefore(prevLine.EndOffset, prevLine.Offset);
if (!(inputText == "{" && lastCharInfo.character == '{'))
{
if (inputText == "{" || inputText == "}")
{
var lastBracketWhitespaceInfo = GetPreviousBracketInfo(editor, editor.Offset - 2);
Indent(editor, editor.Line, lastBracketWhitespaceInfo.whitespace, lastBracketWhitespaceInfo.character);
}
else
{
var lastBracketWhitespaceInfo = GetPreviousBracketInfo(editor, editor.Offset - 1);
if (lastCharInfo.character == ')')
{
Indent(editor, editor.Line, lastBracketWhitespaceInfo.whitespace, lastBracketWhitespaceInfo.character, lastBracketWhitespaceInfo.character == '{' ? 2 : 1, true);
}
else
{
var previousLineText = editor.PreviousLineText().Trim();
if (previousLineText.EndsWith("else"))
{
var lineText = editor.CurrentLineText();
if (!lineText.Contains("{"))
{
Indent(editor, editor.Line, lastBracketWhitespaceInfo.whitespace, lastBracketWhitespaceInfo.character, lastBracketWhitespaceInfo.character == '{' ? 2 : 1, true);
}
}
else
{
Indent(editor, editor.Line, lastBracketWhitespaceInfo.whitespace, lastBracketWhitespaceInfo.character);
}
}
}
}
}
else
{
Indent(editor, editor.Line, null, null);
}
}
return(false);
}
/// <summary>
/// Inserts code at the next line after target AST node.
/// </summary>
public static void InsertCodeAfter(this ITextEditor editor, AbstractNode target, AbstractNode insert, bool updateCaretPos = false)
{
InsertCode(editor, target, insert, editor.Document.GetLineEndOffset(target.EndLocation), updateCaretPos);
}
public override ITextSegmentStyled FindStyledTextSegment(ITextEditor textEditor, ITextSegment textSegment, ITextDocument document, int startIndex, int length, int textColumnIndex)
{
var text = textSegment.GetText(textColumnIndex);
if (startIndex >= text.Length)
{
return(null);
}
foreach (var word in this.WordList)
{
for (var i = 0; i < word.Length; i++)
{
if (word[i] != text[startIndex])
{
continue;
}
var found = true;
var left = i - 1;
for (; left >= 0; left--)
{
var relativeIndex = startIndex - (i - left);
if (relativeIndex < 0)
{
found = false;
break;
}
var c = text[relativeIndex];
if (word[left] != c)
{
found = false;
break;
}
}
if (found == false)
{
break;
}
left = Math.Max(0, left);
var right = i + 1;
for (; right < word.Length; right++)
{
var relativeIndex = startIndex + (right - i);
if (relativeIndex >= text.Length)
{
found = false;
break;
}
var c = text[relativeIndex];
if (word[right] != c)
{
found = false;
break;
}
}
if (found)
{
var newTextSegment = document.CreateStyledTextSegment(this);
var relativeIndex = startIndex - (i - left);
newTextSegment.Index = relativeIndex;
newTextSegment.SetLength(textColumnIndex, right - left);
newTextSegment.Object = word;
return(newTextSegment);
}
}
}
return(null);
}
public bool BeforeTextInput(ITextEditor editor, string inputText)
{
return(false);
}
public override Color GetColorBack(ITextEditor textEditor)
{
return(textEditor.Settings.ColorHighlightBack);
}
protected override bool Refactor(ITextEditor editor, XDocument document)
{
RemoveRecursive(document.Root, "Margin");
return(true);
}
public override void Attach(ITextEditor editor)
{
//CSharpBackgroundCompiler.Init();
}
public override Color GetColorFore(ITextEditor textEditor)
{
return(textEditor.Settings.ColorHighlightFore);
}
ICodeCompletionBinding CreateBinding(ITextEditor editor)
{
return(SD.LanguageService.GetLanguageByExtension(".cs")
.CreateCompletionBinding(FindExpressionToComplete(editor), CreateContext(editor)));
}
public TextEditorContextMenuStrip(ITextEditor editor)
{
_editor = editor;
#region Edit commands
_undo = CreateMenuItem("&Undo", Undo);
_redo = CreateMenuItem("&Redo", Redo);
_cut = CreateMenuItem("Cu&t", Cut);
_copy = CreateMenuItem("&Copy", Copy);
_paste = CreateMenuItem("&Paste", Paste);
_delete = CreateMenuItem("&Delete", Delete);
_selectAll = CreateMenuItem("Select &All", SelectAll);
#endregion
#region Options
_optionsDivider = CreateSeparator();
_options = CreateMenuItem("&Options");
_options.DropDown.Closing += OptionsDropDownOnClosing;
_showLineNumbers = CreateOptionsMenuItem("Show &Line Numbers", ToggleShowLineNumbers);
_showWhiteSpace = CreateOptionsMenuItem("Show &Whitespace", ToggleShowWhiteSpace);
_wordWrap = CreateOptionsMenuItem("Word &Wrap", ToggleWordWrap);
#region Ruler
_ruler = CreateMenuItem("&Ruler");
_ruler.DropDown.Closing += OptionsDropDownOnClosing;
_none = CreateRulerMenuItem("None");
_seventy = CreateRulerMenuItem(70);
_seventyEight = CreateRulerMenuItem(78);
_eighty = CreateRulerMenuItem(80);
_oneHundred = CreateRulerMenuItem(100);
_oneHundredTwenty = CreateRulerMenuItem(120);
_ruler.DropDownItems.AddRange(new ToolStripItem[]
{
_none,
CreateSeparator(),
_seventy,
_seventyEight,
_eighty,
_oneHundred,
_oneHundredTwenty,
});
#endregion
_options.DropDownItems.AddRange(new ToolStripItem[]
{
_showLineNumbers,
_showWhiteSpace,
CreateSeparator(),
_wordWrap,
_ruler,
});
#endregion
#region Top-level menu
base.Items.AddRange(new ToolStripItem[]
{
_undo,
_redo,
CreateSeparator(),
_cut,
_copy,
_paste,
_delete,
CreateSeparator(),
_selectAll,
_optionsDivider,
_options,
});
Opened += (sender, args) => SetMenuItemStates();
#endregion
}
public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
{
// We use HandleKeyPressed instead.
return(CodeCompletionKeyPressResult.None);
}
protected abstract bool Refactor(ITextEditor editor, XDocument document);
