public override void SetReference(IDocument document) { if (diagram != null) { diagram.SelectionChanged -= new EventHandler(diagram_SelectionChanged); } if (document == null) { diagram = null; } else { // TODO do this in a sane way diagram = document as ClassDiagram; if (diagram == null) { throw new Exception("This is not a class diagram"); } diagram.SelectionChanged += new EventHandler(diagram_SelectionChanged); mnuNewStructure.Visible = ((ClassDiagram)diagram).Language.SupportsStructures; mnuNewDelegate.Visible = ((ClassDiagram)diagram).Language.SupportsDelegates; toolNewStructure.Visible = ((ClassDiagram)diagram).Language.SupportsStructures; toolNewDelegate.Visible = ((ClassDiagram)diagram).Language.SupportsDelegates; toolDelete.Enabled = diagram.HasSelectedElement; } }
public override ICodeIssueComputer CheckInlineMethodCondition(IDocument before, IDocument after, IInlineMethodRefactoring refactoring) { // Get the out going symbols before the method is inlined. var writtenSymbolsBeforeInline = ConditionCheckersUtils.GetFlowOutData(ConditionCheckersUtils.GetStatementEnclosingNode (refactoring.InlinedMethodInvocation), before); // Get the out going symbols after the method is inlined. var writtenSymbolsAfterInline = ConditionCheckersUtils.GetFlowOutData(refactoring.InlinedStatementsInMethodAfter, after); // Calculate the symbols that are added by inlining method. var addedSymbols = ConditionCheckersUtils.GetSymbolListExceptByName(writtenSymbolsAfterInline, writtenSymbolsBeforeInline); // Calculate the symbols that are removed by inlining method. var missingSymbols = ConditionCheckersUtils.GetSymbolListExceptByName(writtenSymbolsBeforeInline, writtenSymbolsAfterInline); // Remove 'this' symbol, it is trivial to include. addedSymbols = ConditionCheckersUtils.RemoveThisSymbol(addedSymbols); missingSymbols = ConditionCheckersUtils.RemoveThisSymbol(missingSymbols); // If found any missing and additional symbols, return a code issue computer. if(addedSymbols.Any() || missingSymbols.Any()) { logger.Info("Additional changed symbols: " + StringUtil.ConcatenateAll(",", addedSymbols.Select(s => s.Name))); logger.Info("Missing changed symbols: " + StringUtil.ConcatenateAll(",", missingSymbols.Select(s => s.Name))); return new ModifiedFlowOutData(refactoring.CallerMethodAfter, refactoring.InlinedMethod, refactoring.InlinedMethodInvocation, refactoring.InlinedStatementsInMethodAfter, addedSymbols, missingSymbols); } return new NullCodeIssueComputer(); }
public CurrentFileMembersAsTreeResponse ( IEnumerable<IUnresolvedTypeDefinition> types , IDocument document) { this.TopLevelTypeDefinitions = types .Select(tld => Node.AsTree(tld, document)); }
public BracketSearchResult SearchBracket(IDocument document, int offset) { if (offset > 0) { char c = document.GetCharAt(offset - 1); int index = OpeningBrackets.IndexOf(c); int otherOffset = -1; if (index > -1) otherOffset = SearchBracketForward(document, offset, OpeningBrackets[index], ClosingBrackets[index]); index = ClosingBrackets.IndexOf(c); if (index > -1) otherOffset = SearchBracketBackward(document, offset - 2, OpeningBrackets[index], ClosingBrackets[index]); if (otherOffset > -1) { var result = new BracketSearchResult(Math.Min(offset - 1, otherOffset), 1, Math.Max(offset - 1, otherOffset), 1); SearchDefinition(document, result); return result; } } return null; }
public static void ManageUsings(Gui.IProgressMonitor progressMonitor, string fileName, IDocument document, bool sort, bool removedUnused) { ParseInformation info = ParserService.ParseFile(fileName, document.TextContent); if (info == null) return; ICompilationUnit cu = info.MostRecentCompilationUnit; List<IUsing> newUsings = new List<IUsing>(cu.UsingScope.Usings); if (sort) { newUsings.Sort(CompareUsings); } if (removedUnused) { IList<IUsing> decl = cu.ProjectContent.Language.RefactoringProvider.FindUnusedUsingDeclarations(Gui.DomProgressMonitor.Wrap(progressMonitor), fileName, document.TextContent, cu); if (decl != null && decl.Count > 0) { foreach (IUsing u in decl) { string ns = null; for (int i = 0; i < u.Usings.Count; i++) { ns = u.Usings[i]; if (ns == "System") break; } if (ns != "System") { // never remove "using System;" newUsings.Remove(u); } } } } // put empty line after last System namespace if (sort) { PutEmptyLineAfterLastSystemNamespace(newUsings); } cu.ProjectContent.Language.CodeGenerator.ReplaceUsings(new TextEditorDocument(document), cu.UsingScope.Usings, newUsings); }
/// <summary> /// Creates a new instance off <see cref="DocumentEventArgs"/> /// </summary> public DocumentEventArgs(IDocument document, int offset, int length, string text) { this.document = document; this.offset = offset; this.length = length; this.text = text; }
private static IDocument PrepareCompletionDocument(IDocument document, ref int offset, string usings = null, string variables = null) { if (String.IsNullOrEmpty(document.FileName)) return document; //if the code is just a script it it will contain no namestpace, class and method structure and so the code completion will not work properly // for it to work we have to suround the code with the appropriate code structure //we only process the file if its a .csx file var fileExtension = Path.GetExtension(document.FileName); var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(document.FileName); if (String.IsNullOrEmpty(fileExtension) || String.IsNullOrEmpty(fileNameWithoutExtension)) return document; if (fileExtension.ToLower() == ".csx") { string classname = replaceRegex.Replace(fileNameWithoutExtension, ""); classname = classname.TrimStart('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'); string header = String.Empty; header += (usings ?? "") + Environment.NewLine; header += "public static class " + classname + " {" + Environment.NewLine; header += "public static void Main() {" + Environment.NewLine; header += (variables ?? "") + Environment.NewLine; string footer = "}" + Environment.NewLine + "}" + Environment.NewLine; string code = header + document.Text + Environment.NewLine + footer; offset += header.Length; return new ReadOnlyDocument(new StringTextSource(code), document.FileName); } return document; }
public void Initialize(IDocument document) { if (this.document == null) { this.document = document; this.textDocument = (TextDocument)document.GetService(typeof(TextDocument)); this.changeList = new CompressingTreeList<LineChangeInfo>((x, y) => x.Equals(y)); } var fileName = ((ITextEditor)document.GetService(typeof(ITextEditor))).FileName; InitializeBaseDocument(); if (watcher != null) watcher.Dispose(); if (usedProvider != null) watcher = usedProvider.WatchBaseVersionChanges(fileName, HandleBaseVersionChanges); SetupInitialFileState(fileName != currentFileName); currentFileName = fileName; if (!this.textDocument.LineTrackers.Contains(this)) { this.textDocument.LineTrackers.Add(this); this.textDocument.UndoStack.PropertyChanged += UndoStackPropertyChanged; } }
public void Init() { originalXml = "<root>\r\n" + " <child>\r\n" + " </child>\r\n" + "</root>"; textEditor = new MockTextEditor(); textEditor.OptionsConvertTabsToSpaces = true; textEditor.OptionsIndentationSize = 4; textEditor.OptionsIndentationString = " "; textEditor.Document.Text = originalXml; // Insert new xml as child element of <child>. // Insert position is just before the start of </root> end element. WixDocumentEditor editor = new WixDocumentEditor(textEditor); string xmlToInsert = "<new-child>\r\n" + "</new-child>\r\n"; int line = 3; int column = 5; editor.InsertIndented(line, column, xmlToInsert); document = textEditor.Document; }
public CodeRefactoring GetRefactoring(IDocument document, TextSpan textSpan, CancellationToken cancellationToken) { var tree = (SyntaxTree)document.GetSyntaxTree(cancellationToken); var token = tree.GetRoot().FindToken(textSpan.Start); if (token.Parent is ClassDeclarationSyntax || token.Parent is StructDeclarationSyntax) { var t = (TypeDeclarationSyntax)token.Parent; if (!CanInferNonTrivialConstructor(t)) return null; return new CodeRefactoring(new[] { new ReadyCodeAction("Infer Non-Trivial Constructor", document, t, () => { var c = TryInferNonTrivialConstructor(t, document.TryGetSemanticModel()); var i = 0; var ms = t.Members.Insert(i, new[] {c}).List(); return t.With(members: ms); })}); } if (token.Parent is MemberDeclarationSyntax && (token.Parent.Parent is ClassDeclarationSyntax || token.Parent.Parent is StructDeclarationSyntax)) { var m = (MemberDeclarationSyntax)token.Parent; var t = (TypeDeclarationSyntax)m.Parent; if (!CanInferNonTrivialConstructor(t)) return null; return new CodeRefactoring(new[] { new ReadyCodeAction("Infer Non-Trivial Constructor Here", document, t, () => { var c = TryInferNonTrivialConstructor(t, document.TryGetSemanticModel()); var i = t.Members.IndexOf(m); var ms = t.Members.Insert(i, new[] {c}).List(); return t.With(members: ms); })}); } return null; }
static Selection TryExtendSelectionToComments(IDocument document, Selection selection, IList<ISpecial> commentsBlankLines) { var extendedToComments = ExtendSelectionToComments(document, selection, commentsBlankLines); if (extendedToComments != null) return extendedToComments; return selection; }
public BracketHighlight GetHighlight(IDocument document, int offset) { int searchOffset; if (document.TextEditorProperties.BracketMatchingStyle == BracketMatchingStyle.After) { searchOffset = offset; } else { searchOffset = offset + 1; } char word = document.GetCharAt(Math.Max(0, Math.Min(document.TextLength - 1, searchOffset))); TextLocation endP = document.OffsetToPosition(searchOffset); if (word == opentag) { if (searchOffset < document.TextLength) { int bracketOffset = TextUtilities.SearchBracketForward(document, searchOffset + 1, opentag, closingtag); if (bracketOffset >= 0) { TextLocation p = document.OffsetToPosition(bracketOffset); return new BracketHighlight(p, endP); } } } else if (word == closingtag) { if (searchOffset > 0) { int bracketOffset = TextUtilities.SearchBracketBackward(document, searchOffset - 1, opentag, closingtag); if (bracketOffset >= 0) { TextLocation p = document.OffsetToPosition(bracketOffset); return new BracketHighlight(p, endP); } } } return null; }
static int SearchBracketBackward(IDocument document, int offset, char openBracket, char closingBracket) { bool inString = false; char ch; int brackets = -1; for (int i = offset; i > 0; --i) { ch = document.GetCharAt(i); if (ch == openBracket && !inString) { ++brackets; if (brackets == 0) return i; } else if (ch == closingBracket && !inString) { --brackets; } else if (ch == '"') { inString = !inString; } else if (ch == '\n') { int lineStart = ScanLineStart(document, i); if (lineStart >= 0) { // line could have a comment inString = false; for (int j = lineStart; j < i; ++j) { ch = document.GetCharAt(j); if (ch == '"') inString = !inString; if (ch == '\'' && !inString) { // comment found! // Skip searching in the comment: i = j; break; } } } inString = false; } } return -1; }
public RenderInfo Render(IDocument document) { return new RenderInfo { PartialViewName = "Body", Model = document.Body }; }
public void Initialize(IDocument document) { if (changeList != null && changeList.Any()) return; this.document = document; this.textDocument = (TextDocument)document.GetService(typeof(TextDocument)); this.changeList = new CompressingTreeList<LineChangeInfo>((x, y) => x.Equals(y)); Stream baseFileStream = GetBaseVersion(); // TODO : update baseDocument on VCS actions if (baseFileStream != null) { // ReadAll() is taking care of closing the stream baseDocument = DocumentUtilitites.LoadReadOnlyDocumentFromBuffer(new StringTextBuffer(ReadAll(baseFileStream))); } else { if (baseDocument == null) { // if the file is not under subversion, the document is the opened document var doc = new TextDocument(textDocument.Text); baseDocument = new AvalonEditDocumentAdapter(doc, null); } } SetupInitialFileState(false); this.textDocument.LineTrackers.Add(this); this.textDocument.UndoStack.PropertyChanged += UndoStackPropertyChanged; }
/// <remarks> /// Calculates the fold level of a specific line. /// </remarks> public List<FoldMarker> GenerateFoldMarkers(IDocument document, string fileName, object parseInfo) { var parseInformation = parseInfo as DmModelDB; if (parseInformation == null || parseInformation.Models == null || parseInformation.Models.Count == 0) { return null; } List<FoldMarker> foldMarkers = new List<FoldMarker>(); foreach (var model in parseInformation.Models.Values) { var startLine = model.TokenPair.BeginToken.Line -1; var startColumn = model.TokenPair.BeginToken.CharPositionInLine; var endLine = model.TokenPair.EndToken.Line -1; var endColumn = model.TokenPair.EndToken.CharPositionInLine + 1; var fold = new FoldMarker(document, startLine, startColumn, endLine, endColumn, FoldType.Unspecified, "class " + model.Name); foldMarkers.Add(fold); } //if (parseInformation.BestCompilationUnit != parseInformation.MostRecentCompilationUnit) //{ // List<FoldMarker> oldFoldMarkers = GetFoldMarkers(document, parseInformation.BestCompilationUnit); // int lastLine = (foldMarkers.Count == 0) ? 0 : foldMarkers[foldMarkers.Count - 1].EndLine; // int totalNumberOfLines = document.TotalNumberOfLines; // foreach (FoldMarker marker in oldFoldMarkers) // { // if (marker.StartLine > lastLine && marker.EndLine < totalNumberOfLines) // foldMarkers.Add(marker); // } //} return foldMarkers; }
protected override ICodeIssueComputer CheckCondition(IDocument before, IDocument after, IManualExtractMethodRefactoring input) { // Calculate the outflow data IEnumerable<ISymbol> flowOuts; if (input.ExtractedStatements != null) flowOuts = GetFlowOutData(input.ExtractedStatements, before); else flowOuts = GetFlowOutData(input.ExtractedExpression, before); // Get the returning data of the return statements. var delaration = input.ExtractedMethodDeclaration; var methodAnalyzer = AnalyzerFactory.GetMethodDeclarationAnalyzer(); methodAnalyzer.SetMethodDeclaration(delaration); // Get the returning data in the return statements of the extracted method, also log them. var returningData = GetMethodReturningData(methodAnalyzer, after); // Missing symbols that are in the flow out before but not in the returning data. // Remove this symbol. var missing = ConditionCheckersUtils.RemoveThisSymbol( ConditionCheckersUtils.GetSymbolListExceptByName(flowOuts, returningData)); if (missing.Any()) { return new ReturnTypeCheckingResult(input.ExtractedMethodDeclaration, ConditionCheckersUtils.GetTypeNameTuples(missing)); } return new NullCodeIssueComputer(); }
/// <summary> /// Selects the specified document as the currently active document. /// </summary> /// <param name="document">The document.</param> public void SelectDocument(IDocument document) { if (document == null) throw new ArgumentNullException("document"); ownerUI.ShowView(views[document.Key]); OnDocumentSelected(document); }
public void MarkTokens(IDocument document, List<LineSegment> lines) { var subs = analizer.GetSubQueries(document.TextContent.Replace("\r\n"," "), document.TextLength - 1); baseStrategy.MarkTokens(document, lines); foreach (var line in lines) { foreach (var word in line.Words) { if (!string.IsNullOrEmpty(word.Word.Trim())) { if (word.Word.StartsWith(":")) { word.SyntaxColor = new HighlightColor(Color.BlueViolet,Color.Yellow, true, false); } else { var visible = analizer.GetVisibleSubQueries(subs, word.Offset + line.Offset); var names = analizer.GetVisibleEntityNames(visible, word.Offset + line.Offset); if (names.Any(q => q.Alias.Equals(word.Word.Split('.')[0]))) { word.SyntaxColor = new HighlightColor(Color.DarkGoldenrod, true, true); } else if (names.Any(q => q.EntityName.Equals(word.Word))) { word.SyntaxColor = new HighlightColor(Color.DarkGoldenrod, true, false); } } } } } }
public List<ISegment> GetLinesStartingWith(IDocument document, ref int beginIndex, string[] prefixStrs, ref bool found) { var result = new List<ISegment>(); while (beginIndex < document.TotalNumberOfLines) { var lineSegment = _segmentGetter.GetSegment(document, beginIndex); if (lineSegment.Length > 0 && DoesLineStartWith(document, lineSegment.Offset, prefixStrs)) { found = true; result.Add(lineSegment); beginIndex++; } else { if (found) break; else beginIndex++; } } return result; }
internal static bool SelectionIsReadOnly(IDocument document, ISelection sel) { if (document.TextEditorProperties.SupportReadOnlySegments) return document.MarkerStrategy.GetMarkers(sel.Offset, sel.Length).Exists(m=>m.IsReadOnly); else return false; }
protected override async Task ProcessResponseAsync(IResponse response) { var context = new BrowsingContext(_parentDocument.Context, Sandboxes.None); var options = new CreateDocumentOptions(response, _configuration, _parentDocument); var factory = _configuration.GetFactory<IDocumentFactory>(); ChildDocument = await factory.CreateAsync(context, options, CancellationToken.None).ConfigureAwait(false); }
/// <summary> /// Initializes a new instance of the <see cref="Row"/> class. /// </summary> /// <param name="document">The document.</param> /// <param name="node">The node.</param> public Row(IDocument document, XmlNode node) { this.Document = document; this.Node = node; this.InitStandards(); }
public FixSpellingCodeAction(IDocument document, CommonSyntaxNode syntaxNode, string oldIdentifier, string newIdentifier) { this.Document = document; this.Node = syntaxNode; this.OldIdentifier = oldIdentifier; this.NewIdentifier = newIdentifier; }
public IEnumerable<SyntaxClassification> ClassifyNode(IDocument document, CommonSyntaxNode syntax, CancellationToken cancellationToken) { // If this node is a field declaration, return syntax classifications for the // identifier token of each field name. // // For example, "x" and "y" would be classified in the following code: // // class C // { // int x, y; // } if (syntax is FieldDeclarationSyntax) { var field = (FieldDeclarationSyntax)syntax; return from v in field.Declaration.Variables select new SyntaxClassification(v.Identifier.Span, fieldClassification); } // If this node is an identifier, use the binding API to retrieve its symbol and return a // syntax classification for the node if that symbol is a field. if (syntax is IdentifierNameSyntax) { var semanticModel = document.GetSemanticModel(cancellationToken); var symbol = semanticModel.GetSemanticInfo(syntax).Symbol; if (symbol != null && symbol.Kind == CommonSymbolKind.Field) { return new[] { new SyntaxClassification(syntax.Span, fieldClassification) }; } } return null; }
/// <summary> /// Creates a HTML fragment from a part of a document. /// </summary> /// <param name="document">The document to create HTML from.</param> /// <param name="highlighter">The highlighter used to highlight the document. <c>null</c> is valid and will create HTML without any highlighting.</param> /// <param name="segment">The part of the document to create HTML for. You can pass <c>null</c> to create HTML for the whole document.</param> /// <param name="options">The options for the HTML creation.</param> /// <returns>HTML code for the document part.</returns> public static string CreateHtmlFragment(IDocument document, IHighlighter highlighter, ISegment segment, HtmlOptions options) { if (document == null) throw new ArgumentNullException("document"); if (options == null) throw new ArgumentNullException("options"); if (highlighter != null && highlighter.Document != document) throw new ArgumentException("Highlighter does not belong to the specified document."); if (segment == null) segment = new SimpleSegment(0, document.TextLength); StringBuilder html = new StringBuilder(); int segmentEndOffset = segment.EndOffset; IDocumentLine line = document.GetLineByOffset(segment.Offset); while (line != null && line.Offset < segmentEndOffset) { HighlightedLine highlightedLine; if (highlighter != null) highlightedLine = highlighter.HighlightLine(line.LineNumber); else highlightedLine = new HighlightedLine(document, line); SimpleSegment s = SimpleSegment.GetOverlap(segment, line); if (html.Length > 0) html.AppendLine("<br>"); html.Append(highlightedLine.ToHtml(s.Offset, s.EndOffset, options)); line = line.NextLine; } return html.ToString(); }
/// <exception cref="ArgumentNullException"> /// <paramref name="document"/> is null. /// </exception> public static void Paste(IDocument document) { if (document == null) throw new ArgumentNullException("document"); item.Paste(document); }
/// <summary> /// Constructs and initializes editor. /// </summary> /// <param name="document">Reference to document object.</param> public TableEditor(IDocument document) : base(document) { if (!(document is TableDocument)) throw new ArgumentException( Resources.Error_UnsupportedDocument, "document"); InitializeComponent(); // Set columns grid databindings InitializeColumnsGridDatabindings(); // Change advanced columns grid properties AdjustColumnsGridStyle(); // Initialize column details tab InitColumnDetails(); // Initialize foreign keys tab foreignKeysEdit.Document = Document; // Initialize indexes tab indexesEdit.Document = Document; }
public void SetUp() { document = new DocumentFactory().CreateDocument(); document.TextContent = "0123456789"; marker = new TextMarker(3, 3, TextMarkerType.Underlined); document.MarkerStrategy.AddMarker(marker); }
/// <summary> /// Removes all CodeCoverageMarkers from the marker strategy. /// </summary> public void RemoveMarkers(IDocument document) { ITextMarkerService markerService = document.GetService(typeof(ITextMarkerService)) as ITextMarkerService; if (markerService != null) { markerService.RemoveAll(IsCodeCoverageTextMarker); } }
public HighlightIdentifiersStageProcess([NotNull] IFSharpFile fsFile, [NotNull] IDaemonProcess process) : base(process) { myFsFile = fsFile; myDocument = process.Document; }
/// <summary> /// Returns <see cref="IDocument"/> with default values. /// </summary> /// <param name="data">The data.</param> /// <returns></returns> public static IDocument WithDefaults(this IDocument data) { data.SetDefaults(); return(data); }
/// <summary> /// Converts the <see cref="IDocument"/> into a menu display item model. /// </summary> /// <param name="data">The document.</param> public static MenuDisplayItemModel ToMenuDisplayItemModel(this IDocument data) { return(data.ToMenuDisplayItemModel(group: null)); }
/// <summary> /// Converts the <see cref="IDocument"/> into human-readable display text. /// </summary> /// <param name="data">The data.</param> public static string ToDisplayText(this IDocument data) { return(data.ToDisplayText(showIdOnly: false)); }
protected override async Task Use(Uri url, IDocument document, CancellationToken cancel) { await Task.Yield(); }
public override void Addon(IDocument frm, NameSpace nameSpace) { throw new NotImplementedException(); }
public DockContentAnalysisCylinderPallet(IDocument document, AnalysisCylinderPallet analysis) : base(document, analysis) { InitializeComponent(); }
public CodeCompletionResult GetCompletions(IDocument document, int offset) { return(GetCompletions(document, offset, false)); }
public virtual void DrawThumbnail(IDocument doc, IGraphics g, SizeF size, Theme theme) { g.SetColor(GetThumbnailBackgroundColor(theme)); g.FillRect(new RectangleF(PointF.Empty, size)); }
public CodeCompletionResult GetCompletions(IDocument document, int offset, bool controlSpace, string usings, string variables, string @namespace) { var result = new CodeCompletionResult(); if (String.IsNullOrEmpty(document.FileName)) { return(result); } var completionContext = new CSharpCompletionContext(document, offset, projectContent, usings, variables, @namespace); var completionFactory = new CSharpCompletionDataFactory(completionContext.TypeResolveContextAtCaret, completionContext); var cce = new CSharpCompletionEngine( completionContext.Document, completionContext.CompletionContextProvider, completionFactory, completionContext.ProjectContent, completionContext.TypeResolveContextAtCaret ); cce.EolMarker = Environment.NewLine; cce.FormattingPolicy = FormattingOptionsFactory.CreateSharpDevelop(); var completionChar = completionContext.Document.GetCharAt(completionContext.Offset - 1); int startPos, triggerWordLength; IEnumerable <ICSharpCode.NRefactory.Completion.ICompletionData> completionData; if (controlSpace) { if (!cce.TryGetCompletionWord(completionContext.Offset, out startPos, out triggerWordLength)) { startPos = completionContext.Offset; triggerWordLength = 0; } completionData = cce.GetCompletionData(startPos, true); //this outputs tons of available entities //if (triggerWordLength == 0) // completionData = completionData.Concat(cce.GetImportCompletionData(startPos)); } else { startPos = completionContext.Offset; if (char.IsLetterOrDigit(completionChar) || completionChar == '_') { if (startPos > 1 && char.IsLetterOrDigit(completionContext.Document.GetCharAt(startPos - 2))) { return(result); } completionData = cce.GetCompletionData(startPos, false); startPos--; triggerWordLength = 1; } else { completionData = cce.GetCompletionData(startPos, false); triggerWordLength = 0; } } result.TriggerWordLength = triggerWordLength; result.TriggerWord = completionContext.Document.GetText(completionContext.Offset - triggerWordLength, triggerWordLength); Debug.Print("Trigger word: '{0}'", result.TriggerWord); //cast to AvalonEdit completion data and add to results foreach (var completion in completionData) { var cshellCompletionData = completion as ICSharpCode.CodeCompletion.DataItems.CompletionData; if (cshellCompletionData != null) { cshellCompletionData.TriggerWord = result.TriggerWord; cshellCompletionData.TriggerWordLength = result.TriggerWordLength; result.CompletionData.Add(cshellCompletionData); } } //method completions if (!controlSpace) { // Method Insight var pce = new CSharpParameterCompletionEngine( completionContext.Document, completionContext.CompletionContextProvider, completionFactory, completionContext.ProjectContent, completionContext.TypeResolveContextAtCaret ); var parameterDataProvider = pce.GetParameterDataProvider(completionContext.Offset, completionChar); result.OverloadProvider = parameterDataProvider as IOverloadProvider; } return(result); }
public static int GetOffset([NotNull] this IDocument document, Range.pos pos) { return(GetDocumentOffset(document, (Line)(pos.Line - 1), (Column)pos.Column)); }
public static HtmlString GetTypeLink(this IExecutionContext context, IMetadata metadata, string name, bool linkTypeArguments) { name = name ?? metadata.String(CodeAnalysisKeys.DisplayName); // Link nullable types to their type argument if (metadata.String("Name") == "Nullable") { IDocument nullableType = metadata.DocumentList(CodeAnalysisKeys.TypeArguments)?.FirstOrDefault(); if (nullableType != null) { return(context.GetTypeLink(nullableType, name)); } } // If it wasn't nullable, format the name name = FormatName(name); // Link the type and type parameters seperatly for generic types IReadOnlyList <IDocument> typeArguments = metadata.DocumentList(CodeAnalysisKeys.TypeArguments); if (typeArguments != null && typeArguments.Count > 0) { // Link to the original definition of the generic type metadata = metadata.Document(CodeAnalysisKeys.OriginalDefinition) ?? metadata; if (linkTypeArguments) { // Get the type argument positions int begin = name.IndexOf("<wbr><") + 9; int openParen = name.IndexOf("<wbr>("); int end = name.LastIndexOf("><wbr>", openParen == -1 ? name.Length : openParen); // Don't look past the opening paren if there is one // Remove existing type arguments and insert linked type arguments (do this first to preserve original indexes) name = name .Remove(begin, end - begin) .Insert(begin, string.Join(", <wbr>", typeArguments.Select(x => context.GetTypeLink(x, true).Value))); // Insert the link for the type if (metadata.ContainsKey(Keys.WritePath)) { name = name.Insert(begin - 9, "</a>").Insert(0, $"<a href=\"{context.GetLink(metadata.FilePath(Keys.WritePath))}\">"); } return(new HtmlString(name)); } } // If it's a type parameter, create an anchor link to the declaring type's original definition if (metadata.String("Kind") == "TypeParameter") { IDocument declaringType = metadata.Document(CodeAnalysisKeys.DeclaringType)?.Document(CodeAnalysisKeys.OriginalDefinition); if (declaringType != null) { return(new HtmlString(declaringType.ContainsKey(Keys.WritePath) ? $"<a href=\"{context.GetLink(declaringType.FilePath(Keys.WritePath))}#typeparam-{metadata["Name"]}\">{name}</a>" : name)); } } return(new HtmlString(metadata.ContainsKey(Keys.WritePath) ? $"<a href=\"{context.GetLink(metadata.FilePath(Keys.WritePath))}\">{name}</a>" : name)); }
public static TreeOffset GetTreeOffset([NotNull] IDocument document, Line line, Column column) { return(document.GetLineLength(line) >= column ? new TreeOffset(document.GetOffsetByCoords(new DocumentCoords(line, column))) : TreeOffset.InvalidOffset); }
public LineManager(IDocument document, IHighlightingStrategy highlightingStrategy) { this.document = document; this.highlightingStrategy = highlightingStrategy; }
public static int GetDocumentOffset([NotNull] this IDocument document, Line line, Column column) { return(document.GetLineLength(line) >= column ? document.GetOffsetByCoords(new DocumentCoords(line, column)) : document.GetLineEndOffsetNoLineBreak(line)); }
public static TreeOffset GetTreeEndOffset([NotNull] this IDocument document, Range.range range) { return(GetTreeOffset(document, range.GetEndLine(), range.GetEndColumn())); }
/// <summary> /// Makes the document visible to the user</summary> /// <param name="document">Document to show</param> public void Show(IDocument document) { var viewingContext = document.Cast <ViewingContext>(); m_controlHostService.Show(viewingContext.Control); }
public static int GetDocumentOffset([NotNull] this IDocument document, int line, int column) { return(document.GetDocumentOffset((Line)line, (Column)column)); }
} // Needs to say it exists, otherwise when calling ModelDescription.ExistsAsync(Language language, int version, string tag), it will fail to load this model public void Process(IDocument document) { Normalize(document); }
/// <summary> /// Closes the document and removes any views of it from the UI</summary> /// <param name="document">Document to close</param> public void Close(IDocument document) { m_documentRegistry.Remove(document); }
/// <summary> /// pushes the curWord string on the word list, with the /// correct color. /// </summary> void PushCurWord(IDocument document, ref HighlightColor markNext, List <TextWord> words) { // Svante Lidman : Need to look through the next prev logic. if (currentLength > 0) { if (words.Count > 0 && activeRuleSet != null) { TextWord prevWord = null; int pInd = words.Count - 1; while (pInd >= 0) { if (!((TextWord)words[pInd]).IsWhiteSpace) { prevWord = (TextWord)words[pInd]; if (prevWord.HasDefaultColor) { PrevMarker marker = (PrevMarker)activeRuleSet.PrevMarkers[document, currentLine, currentOffset, currentLength]; if (marker != null) { prevWord.SyntaxColor = marker.Color; // document.Caret.ValidateCaretPos(); // document.RequestUpdate(new TextAreaUpdate(TextAreaUpdateType.SingleLine, document.GetLineNumberForOffset(document.Caret.Offset))); } } break; } pInd--; } } if (inSpan) { HighlightColor c = null; bool hasDefaultColor = true; if (activeSpan.Rule == null) { c = activeSpan.Color; } else { c = GetColor(activeRuleSet, document, currentLine, currentOffset, currentLength); hasDefaultColor = false; } if (c == null) { c = activeSpan.Color; if (c.Color == Color.Transparent) { c = this.DefaultTextColor; } hasDefaultColor = true; } words.Add(new TextWord(document, currentLine, currentOffset, currentLength, markNext != null ? markNext : c, hasDefaultColor)); } else { HighlightColor c = markNext != null ? markNext : GetColor(activeRuleSet, document, currentLine, currentOffset, currentLength); if (c == null) { words.Add(new TextWord(document, currentLine, currentOffset, currentLength, this.DefaultTextColor, true)); } else { words.Add(new TextWord(document, currentLine, currentOffset, currentLength, c, false)); } } if (activeRuleSet != null) { NextMarker nextMarker = (NextMarker)activeRuleSet.NextMarkers[document, currentLine, currentOffset, currentLength]; if (nextMarker != null) { if (nextMarker.MarkMarker && words.Count > 0) { TextWord prevword = ((TextWord)words[words.Count - 1]); prevword.SyntaxColor = nextMarker.Color; } markNext = nextMarker.Color; } else { markNext = null; } } currentOffset += currentLength; currentLength = 0; } }
public void Normalize(IDocument document) { document.Value = document.Value.ToLowerInvariant(); }
protected virtual void OnParsedLine(IDocument document, LineSegment currentLine, List <TextWord> words) { }
/// <summary> /// returns true, if the get the string s2 at index matches the expression expr /// </summary> static bool MatchExpr(LineSegment lineSegment, char[] expr, int index, IDocument document, bool ignoreCase) { for (int i = 0, j = 0; i < expr.Length; ++i, ++j) { switch (expr[i]) { case '@': // "special" meaning ++i; if (i == expr.Length) { throw new HighlightingDefinitionInvalidException("Unexpected end of @ sequence, use @@ to look for a single @."); } switch (expr[i]) { case 'C': // match whitespace or punctuation if (index + j == lineSegment.Offset || index + j >= lineSegment.Offset + lineSegment.Length) { // nothing (EOL or SOL) } else { char ch = document.GetCharAt(lineSegment.Offset + index + j); if (!Char.IsWhiteSpace(ch) && !Char.IsPunctuation(ch)) { return(false); } } break; case '!': // don't match the following expression { StringBuilder whatmatch = new StringBuilder(); ++i; while (i < expr.Length && expr[i] != '@') { whatmatch.Append(expr[i++]); } if (lineSegment.Offset + index + j + whatmatch.Length < document.TextLength) { int k = 0; for (; k < whatmatch.Length; ++k) { char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index + j + k)) : document.GetCharAt(lineSegment.Offset + index + j + k); char spanChar = ignoreCase ? Char.ToUpperInvariant(whatmatch[k]) : whatmatch[k]; if (docChar != spanChar) { break; } } if (k >= whatmatch.Length) { return(false); } } // --j; break; } case '-': // don't match the expression before { StringBuilder whatmatch = new StringBuilder(); ++i; while (i < expr.Length && expr[i] != '@') { whatmatch.Append(expr[i++]); } if (index - whatmatch.Length >= 0) { int k = 0; for (; k < whatmatch.Length; ++k) { char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index - whatmatch.Length + k)) : document.GetCharAt(lineSegment.Offset + index - whatmatch.Length + k); char spanChar = ignoreCase ? Char.ToUpperInvariant(whatmatch[k]) : whatmatch[k]; if (docChar != spanChar) { break; } } if (k >= whatmatch.Length) { return(false); } } // --j; break; } case '@': // matches @ if (index + j >= lineSegment.Length || '@' != document.GetCharAt(lineSegment.Offset + index + j)) { return(false); } break; } break; default: { if (index + j >= lineSegment.Length) { return(false); } char docChar = ignoreCase ? Char.ToUpperInvariant(document.GetCharAt(lineSegment.Offset + index + j)) : document.GetCharAt(lineSegment.Offset + index + j); char spanChar = ignoreCase ? Char.ToUpperInvariant(expr[i]) : expr[i]; if (docChar != spanChar) { return(false); } break; } } } return(true); }
bool MarkTokensInLine(IDocument document, int lineNumber, ref bool spanChanged) { currentLineNumber = lineNumber; bool processNextLine = false; LineSegment previousLine = (lineNumber > 0 ? document.GetLineSegment(lineNumber - 1) : null); currentSpanStack = ((previousLine != null && previousLine.HighlightSpanStack != null) ? previousLine.HighlightSpanStack.Clone() : null); if (currentSpanStack != null) { while (!currentSpanStack.IsEmpty && currentSpanStack.Peek().StopEOL) { currentSpanStack.Pop(); } if (currentSpanStack.IsEmpty) { currentSpanStack = null; } } currentLine = (LineSegment)document.LineSegmentCollection[lineNumber]; if (currentLine.Length == -1) // happens when buffer is empty ! { return(false); } List <TextWord> words = ParseLine(document); if (currentSpanStack != null && currentSpanStack.IsEmpty) { currentSpanStack = null; } // Check if the span state has changed, if so we must re-render the next line // This check may seem utterly complicated but I didn't want to introduce any function calls // or allocations here for perf reasons. if (currentLine.HighlightSpanStack != currentSpanStack) { if (currentLine.HighlightSpanStack == null) { processNextLine = false; foreach (Span sp in currentSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else if (currentSpanStack == null) { processNextLine = false; foreach (Span sp in currentLine.HighlightSpanStack) { if (!sp.StopEOL) { spanChanged = true; processNextLine = true; break; } } } else { SpanStack.Enumerator e1 = currentSpanStack.GetEnumerator(); SpanStack.Enumerator e2 = currentLine.HighlightSpanStack.GetEnumerator(); bool done = false; while (!done) { bool blockSpanIn1 = false; while (e1.MoveNext()) { if (!((Span)e1.Current).StopEOL) { blockSpanIn1 = true; break; } } bool blockSpanIn2 = false; while (e2.MoveNext()) { if (!((Span)e2.Current).StopEOL) { blockSpanIn2 = true; break; } } if (blockSpanIn1 || blockSpanIn2) { if (blockSpanIn1 && blockSpanIn2) { if (e1.Current != e2.Current) { done = true; processNextLine = true; spanChanged = true; } } else { spanChanged = true; done = true; processNextLine = true; } } else { done = true; processNextLine = false; } } } } else { processNextLine = false; } //// Alex: remove old words if (currentLine.Words != null) { currentLine.Words.Clear(); } currentLine.Words = words; currentLine.HighlightSpanStack = (currentSpanStack != null && !currentSpanStack.IsEmpty) ? currentSpanStack : null; return(processNextLine); }
protected virtual bool OverrideSpan(string spanBegin, IDocument document, List <TextWord> words, Span span, ref int lineOffset) { return(false); }
public FoldMarker(IDocument document, int startLine, int startColumn, int endLine, int endColumn, FoldType foldType, string foldText) : this(document, startLine, startColumn, endLine, endColumn, foldType, foldText, false) { }
List <TextWord> ParseLine(IDocument document) { List <TextWord> words = new List <TextWord>(); HighlightColor markNext = null; currentOffset = 0; currentLength = 0; UpdateSpanStateVariables(); int currentLineLength = currentLine.Length; int currentLineOffset = currentLine.Offset; for (int i = 0; i < currentLineLength; ++i) { char ch = document.GetCharAt(currentLineOffset + i); switch (ch) { case '\n': case '\r': PushCurWord(document, ref markNext, words); ++currentOffset; break; case ' ': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.SpaceTextWord(activeSpan.Color)); } else { words.Add(TextWord.Space); } ++currentOffset; break; case '\t': PushCurWord(document, ref markNext, words); if (activeSpan != null && activeSpan.Color.HasBackground) { words.Add(new TextWord.TabTextWord(activeSpan.Color)); } else { words.Add(TextWord.Tab); } ++currentOffset; break; default: { // handle escape characters char escapeCharacter = '\0'; if (activeSpan != null && activeSpan.EscapeCharacter != '\0') { escapeCharacter = activeSpan.EscapeCharacter; } else if (activeRuleSet != null) { escapeCharacter = activeRuleSet.EscapeCharacter; } if (escapeCharacter != '\0' && escapeCharacter == ch) { // we found the escape character if (activeSpan != null && activeSpan.End != null && activeSpan.End.Length == 1 && escapeCharacter == activeSpan.End[0]) { // the escape character is a end-doubling escape character // it may count as escape only when the next character is the escape, too if (i + 1 < currentLineLength) { if (document.GetCharAt(currentLineOffset + i + 1) == escapeCharacter) { currentLength += 2; PushCurWord(document, ref markNext, words); ++i; continue; } } } else { // this is a normal \-style escape ++currentLength; if (i + 1 < currentLineLength) { ++currentLength; } PushCurWord(document, ref markNext, words); ++i; continue; } } // highlight digits if (!inSpan && (Char.IsDigit(ch) || (ch == '.' && i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1)))) && currentLength == 0) { bool ishex = false; bool isfloatingpoint = false; if (ch == '0' && i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'X') // hex digits { const string hex = "0123456789ABCDEF"; ++currentLength; ++i; // skip 'x' ++currentLength; ishex = true; while (i + 1 < currentLineLength && hex.IndexOf(Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1))) != -1) { ++i; ++currentLength; } } else { ++currentLength; while (i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (!ishex && i + 1 < currentLineLength && document.GetCharAt(currentLineOffset + i + 1) == '.') { isfloatingpoint = true; ++i; ++currentLength; while (i + 1 < currentLineLength && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'E') { isfloatingpoint = true; ++i; ++currentLength; if (i + 1 < currentLineLength && (document.GetCharAt(currentLineOffset + i + 1) == '+' || document.GetCharAt(currentLine.Offset + i + 1) == '-')) { ++i; ++currentLength; } while (i + 1 < currentLine.Length && Char.IsDigit(document.GetCharAt(currentLineOffset + i + 1))) { ++i; ++currentLength; } } if (i + 1 < currentLine.Length) { char nextch = Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)); if (nextch == 'F' || nextch == 'M' || nextch == 'D') { isfloatingpoint = true; ++i; ++currentLength; } } if (!isfloatingpoint) { bool isunsigned = false; if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'U') { ++i; ++currentLength; isunsigned = true; } if (i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'L') { ++i; ++currentLength; if (!isunsigned && i + 1 < currentLineLength && Char.ToUpper(document.GetCharAt(currentLineOffset + i + 1)) == 'U') { ++i; ++currentLength; } } } words.Add(new TextWord(document, currentLine, currentOffset, currentLength, DigitColor, false)); currentOffset += currentLength; currentLength = 0; continue; } // Check for SPAN ENDs if (inSpan) { if (activeSpan.End != null && activeSpan.End.Length > 0) { if (MatchExpr(currentLine, activeSpan.End, i, document, activeSpan.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = GetRegString(currentLine, activeSpan.End, i, document); currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, activeSpan.EndColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; currentSpanStack.Pop(); UpdateSpanStateVariables(); continue; } } } // check for SPAN BEGIN if (activeRuleSet != null) { foreach (Span span in activeRuleSet.Spans) { if ((!span.IsBeginSingleWord || currentLength == 0) && (!span.IsBeginStartOfLine.HasValue || span.IsBeginStartOfLine.Value == (currentLength == 0 && words.TrueForAll(delegate(TextWord textWord) { return(textWord.Type != TextWordType.Word); }))) && MatchExpr(currentLine, span.Begin, i, document, activeRuleSet.IgnoreCase)) { PushCurWord(document, ref markNext, words); string regex = GetRegString(currentLine, span.Begin, i, document); if (!OverrideSpan(regex, document, words, span, ref i)) { currentLength += regex.Length; words.Add(new TextWord(document, currentLine, currentOffset, currentLength, span.BeginColor, false)); currentOffset += currentLength; currentLength = 0; i += regex.Length - 1; if (currentSpanStack == null) { currentSpanStack = new SpanStack(); } currentSpanStack.Push(span); span.IgnoreCase = activeRuleSet.IgnoreCase; UpdateSpanStateVariables(); } goto skip; } } } // check if the char is a delimiter if (activeRuleSet != null && (int)ch < 256 && activeRuleSet.Delimiters[(int)ch]) { PushCurWord(document, ref markNext, words); if (currentOffset + currentLength + 1 < currentLine.Length) { ++currentLength; PushCurWord(document, ref markNext, words); goto skip; } } ++currentLength; skip : continue; } } } PushCurWord(document, ref markNext, words); OnParsedLine(document, currentLine, words); return(words); }
public FoldMarker(IDocument document, int startLine, int startColumn, int endLine, int endColumn, FoldType foldType) : this(document, startLine, startColumn, endLine, endColumn, foldType, "...") { }
public HighlightColor GetColor(IDocument document, LineSegment currentSegment, int currentOffset, int currentLength) { return(GetColor(defaultRuleSet, document, currentSegment, currentOffset, currentLength)); }