public void Execute() { foreach (IndentSquareBracket Bracket in Children) { //向下一行,[ 不需要缩进,后续子Bracket的缩进是建立在 [ 的缩进深度的基础上 Bracket.Start.LineDown(); EditPoint CurrentEditLintPoint = Bracket.Start.CreateEditPoint(); if (CurrentEditLintPoint == null) { continue; } //循环本区间的每行,删除空白,后面根据层级深度,添加缩进 do { //检查是否在在括号内,子括号内的内容,交给子括号处理 if (Bracket.EditLineIsInChildren(CurrentEditLintPoint)) { CurrentEditLintPoint.LineDown(); continue; } //处理缩进,对比应该的缩进深度,大于缩进深度,则剔除,小于则添加 HandleIndent(Bracket, CurrentEditLintPoint); CurrentEditLintPoint.LineDown(); } while (CurrentEditLintPoint.Line <= Bracket.End.Line);//同时处理最后一个 ] 跟 [ 的深度保持一致 //遍历执行所有的子Bracket Bracket.Execute(); } }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void Execute(object sender, EventArgs e) { // Verify the current thread is the UI thread. ThreadHelper.ThrowIfNotOnUIThread(); // This command will only work when there's an active document to examine. if (FormatCommentCommand.environment.ActiveDocument == null) { return; } // Get the selected text from the environment. TextSelection selection = FormatCommentCommand.environment.ActiveDocument.Selection as TextSelection; // Get the start end points (round down and up to the start of a line). EditPoint startPoint = selection.AnchorPoint.CreateEditPoint(); startPoint.StartOfLine(); // The initial endpoint is one line below the start. EditPoint endPoint = selection.ActivePoint.CreateEditPoint(); endPoint.StartOfLine(); endPoint.LineDown(1); // If nothing is selected, then figure out what needs to be formatted by the start point up and the end point down. As long as we // recognize a comment line we'll keep expanding the selection in both directions. if (selection.IsEmpty) { // Find the start of the block. while (!startPoint.AtStartOfDocument) { if (!FormatCommentCommand.IsCommentLine(startPoint)) { startPoint.LineDown(1); break; } startPoint.LineUp(1); } // Find the end of the block. while (!endPoint.AtEndOfDocument) { if (!FormatCommentCommand.IsCommentLine(endPoint)) { break; } endPoint.LineDown(1); } } // This will swap the old comment for the new right-margin justified and beautified comment. startPoint.ReplaceText( endPoint, FormatCommentCommand.FormatCommentstring(startPoint.GetText(endPoint)), (int)(vsEPReplaceTextOptions.vsEPReplaceTextNormalizeNewlines | vsEPReplaceTextOptions.vsEPReplaceTextTabsSpaces)); }
/// <summary> /// Reformat all comments between the specified start and end point. Comments that start /// within the range, even if they overlap the end are included. /// </summary> /// <param name="textDocument">The text document.</param> /// <param name="start">The start point.</param> /// <param name="end">The end point.</param> public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end) { bool foundComments = false; int tabSize = CodeCommentHelper.GetTabSize(_package, textDocument); while (start.Line <= end.Line) { if (CodeCommentHelper.IsCommentLine(start)) { var comment = new CodeComment(start, tabSize); if (comment.IsValid) { comment.Format(); foundComments = true; } if (comment.EndPoint != null) { start = comment.EndPoint.CreateEditPoint(); } } if (start.Line == textDocument.EndPoint.Line) { break; } start.LineDown(); start.StartOfLine(); } return(foundComments); }
private static int GetCodeBehindLineFromLinePragmas(TextDocument codeBehindDoc, int sourceLine) { EditPoint start = codeBehindDoc.StartPoint.CreateEditPoint(); int lineCount = codeBehindDoc.EndPoint.Line; while (start.Line <= lineCount - 1) { start.LineDown(); string lineText = start.GetText(start.LineLength); //#line 8 //#ExternalSource("SpecFlowFeature2.feature",8) var match = linePragmaRe.Match(lineText); if (match.Success) { int linePragmaValue; if (int.TryParse(match.Groups["lineno"].Value, out linePragmaValue)) { if (linePragmaValue >= sourceLine) { return(start.Line + 1); } } } } return(0); }
/// <summary> /// Reformat all comments between the specified start and end point. Comments that start /// within the range, even if they overlap the end are included. /// </summary> /// <param name="textDocument">The text document.</param> /// <param name="start">The start point.</param> /// <param name="end">The end point.</param> public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end) { bool foundComments = false; int tabSize = CodeCommentHelper.GetTabSize(_package, textDocument); while (start.Line <= end.Line) { if (CodeCommentHelper.IsCommentLine(start)) { var comment = new CodeComment(start, tabSize); if (comment.IsValid) { comment.Format(); foundComments = true; } if (comment.EndPoint != null) { start = comment.EndPoint.CreateEditPoint(); } } if (start.Line == textDocument.EndPoint.Line) { break; } start.LineDown(); start.StartOfLine(); } return foundComments; }
/// <summary> /// Performs the style task. /// </summary> /// <param name="projectItem">The project Item</param> /// <param name="ideWindow">The IDE window.</param> protected override void DoWork(ProjectItem projectItem, EnvDTE.Window ideWindow) { if (projectItem.Name.EndsWith(".cs")) { Debug.WriteLine("Removing Unnecessary Blank Lines: " + projectItem.Name); try { TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument"); EditPoint objEditPoint = objTextDoc.CreateEditPoint(objTextDoc.StartPoint); while (!objEditPoint.AtEndOfDocument) { int secondFarthestLine = objEditPoint.Line + 2; if (secondFarthestLine > objTextDoc.EndPoint.Line) { secondFarthestLine = objEditPoint.Line + 1; } if (objEditPoint.GetLines(objEditPoint.Line, secondFarthestLine).Trim() == string.Empty) { objEditPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); objEditPoint.Insert("\r\n"); } objEditPoint.LineDown(1); } } catch (Exception exc) { Debug.WriteLine(exc.ToString()); Debug.WriteLine("Removing Unnecessary Blank Lines failed, skipping"); } } }
private static async Task AddCommentsAsync(EditPoint objEditPt) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); objEditPt.StartOfLine(); var template = GetTemplate(); int index = 0; while (index < template.Count) { var line = string.Empty; if (!objEditPt.AtEndOfDocument) { line = objEditPt.GetText(objEditPt.LineLength); } if (!string.Equals(line, template[index])) { objEditPt.Insert($"{template[index]}{Environment.NewLine}"); //objEditPt.LineDown(); objEditPt.StartOfLine(); } else { objEditPt.LineDown(); } index++; } }
/// <summary> /// Reformat all comments between the specified start and end point. Comments that start /// within the range, even if they overlap the end are included. /// </summary> /// <param name="textDocument">The text document.</param> /// <param name="start">The start point.</param> /// <param name="end">The end point.</param> public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end) { var options = new CodeCommentOptions(Settings.Default, _package, textDocument); bool foundComments = false; while (start.Line <= end.Line) { if (CodeCommentHelper.IsCommentLine(start)) { var comment = new CodeComment(start); if (comment.IsValid) { comment.Format(options); foundComments = true; } if (comment.EndPoint != null) { start = comment.EndPoint.CreateEditPoint(); } } if (start.Line == textDocument.EndPoint.Line) { break; } start.LineDown(); start.StartOfLine(); } return(foundComments); }
public sealed override void Undo() { EditPoint ep = _codeMethod.StartPoint.CreateEditPoint(); ep.LineDown(1); ep.Delete(_codeMethod.EndPoint); ep.Insert("{\r\n}"); }
public static void DeleteCurrentLine(this EditPoint start) { start.StartOfLine(); var point = start.CreateEditPoint(); start.LineDown(); start.StartOfLine(); point.Delete(start); }
public void LineDown(int line, int lineCount) { EditPoint editPoint = GetEditPoint(line, 0); if (editPoint != null) { editPoint.LineDown(lineCount); } }
/// <summary> /// Sorts all using statements in ascending order, with System using statements on top. /// </summary> /// <param name="usingStatementsItems">List of using Statement codeItems</param> /// <param name="namespaceItems">List of namespace codeItems</param> internal void MoveUsingStatementsWithinNamespace(List <CodeItemUsingStatement> usingStatementsItems, List <CodeItemNamespace> namespaceItems) { if (namespaceItems.Count != 1) { //We return back as is, if multiple namespaces are found. return; } CodeItemNamespace theOnlyNamespace = namespaceItems.First(); EditPoint namespaceInsertCursor = theOnlyNamespace.StartPoint; // Setting the start point where we will start inserting using statements. namespaceInsertCursor.LineDown(); namespaceInsertCursor.CharRight(); namespaceInsertCursor.Insert(Environment.NewLine); //Sort the using code items in ascending string order, with system usings on top. usingStatementsItems.Sort((usingStatement1Item, usingStatement2Item) => { string textOfUsingStatement1 = usingStatement1Item.StartPoint.GetText(usingStatement1Item.EndPoint); string textOfUsingStatement2 = usingStatement2Item.StartPoint.GetText(usingStatement2Item.EndPoint); var referenceNameOfStatement1 = ExtractUsingStatementReferenceName(textOfUsingStatement1); var referenceNameOfStatement2 = ExtractUsingStatementReferenceName(textOfUsingStatement2); if (IsSystemReference(referenceNameOfStatement1) && !IsSystemReference(referenceNameOfStatement2)) { return(-1); } else if (!IsSystemReference(referenceNameOfStatement1) && IsSystemReference(referenceNameOfStatement2)) { return(1); } else { return(string.Compare(referenceNameOfStatement1, referenceNameOfStatement2)); } }); foreach (var usingStatement in usingStatementsItems) { var startPoint = usingStatement.StartPoint; var endPoint = usingStatement.EndPoint; string text = startPoint.GetText(usingStatement.EndPoint); startPoint.Delete(usingStatement.EndPoint); namespaceInsertCursor.Insert(text); namespaceInsertCursor.Indent(Count: 1); namespaceInsertCursor.Insert(Environment.NewLine); } }
internal static void InsertBlankLineAfterPoint(EditPoint point) { if (point.AtEndOfDocument) return; point.LineDown(1); point.StartOfLine(); string text = point.GetLines(point.Line, point.Line + 1); if (Regex.IsMatch(text, @"^\s*[^\s\}]")) { point.Insert(Environment.NewLine); } }
/// <summary> /// Generates code in /// </summary> /// <param name="genAttr"></param> /// <param name="parentWriter"></param> /// <remarks></remarks> private void GenInMember(NotifyPropertyChanged_GenAttribute genAttr, Writer parentWriter) { var prop = genAttr.ParentProperty; //!Parent can be either CodeFunction(only for ExtraNotifications) or CodeProperty string code = null; switch (genAttr.GenerationType) { case NotifyPropertyChanged_GenAttribute.GenerationTypes.NotifyOnly: //Only notification code = string.Format("this.NotifyChanged({0})", prop.Name); break; default: code = (genAttr.ParentProperty != null) ? string.Format("this.SetPropertyAndNotify(ref _{0}, value, \"{0}\");", prop.Name) : ""; break; } //Extra notifications var extraNotifyCode = GenInMember_ExtraNotifications(genAttr, parentWriter); code = code.Conjoin(Environment.NewLine, extraNotifyCode); //Code Element, could be property setter or a method var codeElement = (CodeFunction2)((prop != null) ? prop.Setter : genAttr.ParentFunction); var memberWriter = new Writer(parentWriter) { GenAttribute = genAttr, SearchStart = codeElement.StartPoint, SearchEnd = codeElement.EndPoint, Content = code, SegmentType = Types.Statements }; //Find insertion point EditPoint insertPoint = null; var insertTag = Manager.FindInsertionPoint(memberWriter); if (insertTag == null) { //!No insertion point tag specified, by default insert as last line of setter insertPoint = codeElement.GetPositionBeforeClosingBrace(); //always insert new line in case the everything in one line } else { //!InsertPoint Tag found, insert right after it insertPoint = insertTag.EndPoint.CreateEditPoint(); insertPoint.LineDown(1); insertPoint.StartOfLine(); } memberWriter.InsertStart = insertPoint; Manager.InsertOrReplace(memberWriter); }
private static IEnumerable <(string line, int index)> GetLines(this TextDocument document) { EditPoint currentLine = document.CreateEditPoint(); int processedLineIndex; do { string lineText = currentLine.GetText(currentLine.LineLength); yield return(lineText, currentLine.Line - 1); processedLineIndex = currentLine.Line; currentLine.LineDown(); }while (processedLineIndex != currentLine.Line); }
public static string GetNextLineText(this EditPoint point) { point.LineDown(); point.StartOfLine(); var start = point.CreateEditPoint(); point.EndOfLine(); var end = point.CreateEditPoint(); string text = start.GetText(end); point.LineUp(); return(text); }
public override string GetLine(int lineIndex) { if (dte == null || dte.ActiveDocument == null) { return(""); } EnvDTE.TextDocument objTextDoc = GetCurrentVSTextDocument(); EditPoint ep = objTextDoc.StartPoint.CreateEditPoint(); ep.LineDown(lineIndex - 1); EditPoint ep2 = ep.CreateEditPoint(); ep2.EndOfLine(); return(ep.GetText(ep2)); }
public bool CreateSynchClass() { CodeClass synchClass = _cc.AddClass("Synch" + _cc.Name, -1, 0, 0, EnvDTE.vsCMAccess.vsCMAccessPrivate); synchClass.AddBase(_cc, -1); //member variables synchClass.AddVariable("_root", "System.Object", -1, EnvDTE.vsCMAccess.vsCMAccessPrivate, null); synchClass.AddVariable("_parent", _cc.FullName, -1, EnvDTE.vsCMAccess.vsCMAccessPrivate, null); //constructor - add function can't handle this at the moment EditPoint classEndPt = synchClass.EndPoint.CreateEditPoint(); classEndPt.StartOfLine(); classEndPt.Insert("\n"); EditPoint editPt = synchClass.StartPoint.CreateEditPoint(); editPt.LineDown(3); editPt.EndOfLine(); editPt.Insert("\ninternal " + synchClass.Name + "(" + _cc.Name + " parent){\n_parent = parent;\n_root = parent.SyncRoot;\n}\n"); editPt.MoveToPoint(synchClass.StartPoint); editPt.SmartFormat(synchClass.EndPoint); //functions, properties and indexers for (CodeType ct = (CodeType)_cc; ct != null;) { if (!AddMemberElementsFromType(ct, synchClass)) { return(false); } if (ct.Bases.Count != 0) { ct = (CodeType)(ct.Bases.Item(1)); if (ct.Name == "Object") { break; } } } synchClass.StartPoint.CreateEditPoint().SmartFormat(synchClass.EndPoint); return(true); }
/// <summary> /// Checks to see if there should be additional blank lines after the end of a block. /// </summary> /// <param name="element">The current element to check</param> private void CheckBlockEnd(CodeElement element) { EditPoint endBlock = element.GetEndPoint(vsCMPart.vsCMPartWholeWithAttributes).CreateEditPoint(); EditPoint startBlock = element.GetStartPoint(vsCMPart.vsCMPartWholeWithAttributes).CreateEditPoint(); string original = startBlock.GetText(endBlock); EditPoint endOfEnd = endBlock.CreateEditPoint(); endOfEnd.EndOfLine(); string endOfBlockLine = endBlock.GetText(endOfEnd).Trim(); if (element.Kind == vsCMElement.vsCMElementAttribute || element.Kind == vsCMElement.vsCMElementOther) { if (endOfBlockLine != "]" && endOfBlockLine != ")]" && !endOfBlockLine.StartsWith(",")) { endOfEnd = endBlock.CreateEditPoint(); endOfEnd.EndOfLine(); endOfBlockLine = endBlock.GetText(endOfEnd).Trim(); if (endOfBlockLine != string.Empty) { endBlock.Insert(Environment.NewLine); endBlock.SmartFormat(endOfEnd); } } } else if (endOfBlockLine != string.Empty) { endBlock.Insert(Environment.NewLine); endBlock.SmartFormat(endOfEnd); } if (element.Kind != vsCMElement.vsCMElementImportStmt && element.Kind != vsCMElement.vsCMElementAttribute && element.Kind != vsCMElement.vsCMElementOther) { endOfEnd.LineDown(1); endOfEnd.EndOfLine(); string lineAfterBlock = endBlock.GetText(endOfEnd).Trim(); if (lineAfterBlock != string.Empty && !lineAfterBlock.StartsWith("else") && !lineAfterBlock.StartsWith("}")) { endBlock.Insert(Environment.NewLine); endBlock.SmartFormat(endOfEnd); } } }
/// <summary> /// Inserts a blank line after the specified point except where adjacent to a brace. /// </summary> /// <param name="point">The point.</param> internal static void InsertBlankLineAfterPoint(EditPoint point) { if (point.AtEndOfDocument) { return; } point.LineDown(1); point.StartOfLine(); string text = point.GetLine(); if (RegexNullSafe.IsMatch(text, @"^\s*[^\s\}]")) { point.Insert(Environment.NewLine); } }
/// <summary> /// Checks the document in the window for preprocessor directives. /// </summary> /// <param name="ideWindow">The window of the document to check.</param> /// <returns>True if there are preprocessor directives present.</returns> private bool CheckForPreprocessorDirectives(EnvDTE.Window ideWindow) { TextDocument doc = (TextDocument)ideWindow.Document.Object("TextDocument"); EditPoint editPoint = doc.CreateEditPoint(doc.StartPoint); while (!editPoint.AtEndOfDocument) { if (editPoint.GetLines(editPoint.Line, editPoint.Line + 1).StartsWith("#")) { return(true); } editPoint.LineDown(1); } return(false); }
public void FindBracket() { EditPoint EndPoint = null; TextRanges dummy = null; EditPoint StartPoint = Start.CreateEditPoint(); StartPoint.LineDown(); //FindPattern 不能指定结束位置 while (StartPoint.FindPattern(MaximumBracketPattern, StandardFindOptions, ref EndPoint, ref dummy)) { //所以,需要 判读匹配的开始位置是否在,被包含的区间外 if (StartPoint.Line >= End.Line) { break;//在外面,则跳出,转入数组的下一个 } if (StartPoint != null && EndPoint != null) { IndentSquareBracket Child = new IndentSquareBracket(StartPoint, EndPoint, this); StartPoint.StartOfLine(); int LineIndentCount; //当父节区间为空时,取父区间的缩进,否则在父区间的基础上+1,逐级实现缩进 if (Parent == null) { string LineText = StartPoint.GetText(StartPoint.LineLength); string textTemp = LineText.TrimStart('\t'); LineIndentCount = LineText.Length - textTemp.Length;//获取当前的缩进深度 } else { LineIndentCount = IndentCount + 1; } Child.IndentCount = LineIndentCount; Children.Add(Child); //子Bracket递归查找 Child.FindBracket(); } //再从区间的结束位置向后在下一个最大的包含区间 StartPoint = EndPoint; } }
private int FindPatternInDocument(TextDocument codeBehindDoc, params string[] patternsToLookFor) { EditPoint start = codeBehindDoc.StartPoint.CreateEditPoint(); int lineCount = codeBehindDoc.EndPoint.Line; while (start.Line <= lineCount - 1) { start.LineDown(); string lineText = start.GetText(start.LineLength); if (patternsToLookFor.Any(lineText.Contains)) { return(start.Line + 1); } } return(0); }
/// <summary> /// Get and position EditPoint objects to include all of original text that is selected, plus surrounding text for complete lines of text /// </summary> /// <param name="document"></param> /// <param name="earlierPoint"></param> /// <param name="laterPoint"></param> public void GetEditPointsForLinesToCheck(TextDocument document, out EditPoint earlierPoint, out EditPoint laterPoint) { TextSelection selection = document.Selection; // Reorder selection points as needed if (selection.IsActiveEndGreater) { selection.SwapAnchor(); } // Get and position EditPoint objects to include all of original text that is selected, plus surrounding text for complete lines of text earlierPoint = selection.ActivePoint.CreateEditPoint(); laterPoint = selection.AnchorPoint.CreateEditPoint(); earlierPoint.StartOfLine(); laterPoint.LineDown(1); laterPoint.StartOfLine(); }
/// <summary> /// Reformat all comments between the specified start and end point. Comments that start /// within the range, even if they overlap the end are included. /// </summary> /// <param name="textDocument">The text document.</param> /// <param name="start">The start point.</param> /// <param name="end">The end point.</param> public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end) { bool foundComments = false; var options = FormatterOptions .FromSettings(Settings.Default) .Set(o => { o.TabSize = textDocument.TabSize; o.IgnoreTokens = CodeCommentHelper .GetTaskListTokens(_package) .Concat(Settings.Default.Formatting_IgnoreLinesStartingWith.Cast <string>()) .ToArray(); }); while (start.Line <= end.Line) { if (CodeCommentHelper.IsCommentLine(start)) { var comment = new CodeComment(start, options); if (comment.IsValid) { comment.Format(); foundComments = true; } if (comment.EndPoint != null) { start = comment.EndPoint.CreateEditPoint(); } } if (start.Line == textDocument.EndPoint.Line) { break; } start.LineDown(); start.StartOfLine(); } return(foundComments); }
private Tuple <TextPoint, TextPoint> GetCodeRange() { // The C# and VB code models don't return comments with vsCMPartWholeWithAttributes // (even though some of the member types have Comment and DocComment properties // and the code model's RemoveMember will remove the comments). So we have to // grab any attached comment lines manually. TextPoint startPoint = this.element.GetStartPoint(vsCMPart.vsCMPartWholeWithAttributes); TextPoint endPoint = this.element.GetEndPoint(vsCMPart.vsCMPartWholeWithAttributes); Regex commentRegex; switch (this.language) { case Language.CSharp: // Look for lines starting with optional whitespace followed by //, /*, */, or *. commentRegex = new Regex(@"^\s*(//|/\*|\*/|\*)"); break; case Language.VB: // Look for lines starting with optional whitespace followed by '. commentRegex = new Regex(@"^\s*'"); break; default: throw new NotSupportedException("Unsupported language: " + this.language); } EditPoint startEdit = startPoint.CreateEditPoint(); startEdit.LineUp(); while (!startEdit.AtStartOfDocument && commentRegex.IsMatch(startEdit.GetLines(startEdit.Line, startEdit.Line + 1))) { startEdit.LineUp(); startEdit.StartOfLine(); } startEdit.LineDown(); startEdit.StartOfLine(); Tuple <TextPoint, TextPoint> result = Tuple.Create((TextPoint)startEdit, endPoint); return(result); }
public void CommentSelectedText() { TextSelection textSelection = ActiveTextSelection; if (textSelection != null) { //editpoint,virsualpoint 都继承于TextPoint EditPoint topEditPoint = textSelection.TopPoint.CreateEditPoint(); TextPoint bottomPoint = textSelection.BottomPoint; UndoContext undoContext = ApplicationObject.UndoContext; undoContext.Open("Comment Region"); while (topEditPoint.LessThan(bottomPoint)) { topEditPoint.Insert("//"); topEditPoint.LineDown(); topEditPoint.StartOfLine(); } undoContext.Close(); } }
/// <summary> /// Returns an adjusted CodeElement. Walks comments 'down' to the next real element. /// From Rick Strahl's Weblog /// </summary> /// <returns></returns> static public CodeElement GetCodeElementFromActivePoint() { EditPoint selPoint = GetActiveEditPoint(); if (selPoint == null) { return(null); } selPoint.StartOfLine(); while (true) { if (selPoint.AtEndOfDocument) { break; } string BlockText = selPoint.GetText(selPoint.LineLength).Trim(); // *** Skip over any XML Doc comments if (BlockText.StartsWith("//")) { selPoint.LineDown(1); selPoint.StartOfLine(); } else { break; } } // *** Make sure the cursor is placed inside of the definition always // *** Especially required for single line methods/fields/events etc. selPoint.EndOfLine(); selPoint.CharLeft(1); // Force into the text return(GetActiveCodeElement()); }
/// <summary> /// Helper method to modify commands.xml. /// </summary> /// <param name="projectItem"></param> private void ModifyCommandTable(ProjectItem projectItem) { Document activeDoc = projectItem.Document; projectItem.Open(); TextDocument editDoc = (TextDocument)activeDoc.Object("TextDocument"); EditPoint objEditPt = editDoc.CreateEditPoint(); EditPoint objMovePt = editDoc.EndPoint.CreateEditPoint(); objEditPt.StartOfDocument(); activeDoc.ReadOnly = false; objEditPt.FindPattern("</KeyinTable>"); objEditPt.Insert("\n"); objEditPt.LineUp(1); objEditPt.Indent(objEditPt, 1); objEditPt.Insert("<Keyword CommandWord=\"" + FunctionName + "\"></Keyword>"); objEditPt.LineDown(1); objEditPt.Indent(objEditPt, 2); objEditPt.FindPattern("</KeyinHandlers>"); objEditPt.Insert("\n"); objEditPt.LineUp(1); objEditPt.Indent(objEditPt, 1); objEditPt.Insert("<KeyinHandler Keyin=\"" + RootNamespace + " " + FunctionName + "\"\n"); objEditPt.Indent(objEditPt, 4); if (!IsVBProject) { objEditPt.Insert("Function=\"" + RootNamespace + ".KeyinCommands." + FunctionName + "Keyin\"/>"); } else { objEditPt.Insert("Function=\"" + RootNamespace + ".KeyinCommands." + FunctionName + "Keyin\"/>"); } }
/// <summary> /// Reformat all comments between the specified start and end point. Comments that start /// within the range, even if they overlap the end are included. /// </summary> /// <param name="textDocument">The text document.</param> /// <param name="start">The start point.</param> /// <param name="end">The end point.</param> public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end) { var options = new CodeCommentOptions(Settings.Default, _package, textDocument); bool foundComments = false; while (start.Line <= end.Line) { if (CodeCommentHelper.IsCommentLine(start)) { var comment = new CodeComment(start); if (comment.IsValid) { comment.Format(options); foundComments = true; } if (comment.EndPoint != null) { start = comment.EndPoint.CreateEditPoint(); } } if (start.Line == textDocument.EndPoint.Line) { break; } start.LineDown(); start.StartOfLine(); } return foundComments; }
public static bool DeleteCodeSite(this CodeFunction value, bool bDelete = true) { if (bDelete && !value.ExistsCodeSite()) { return(true); } EditPoint epStart = value.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); EditPoint epEnd = value.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); EditPoint epFind = null, epFindStart = null; bool Find(string text, bool start) { string[] textSplit; if (start) { epFind = epStart.CreateEditPoint(); textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); } else { epFind = epEnd.CreateEditPoint(); textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToArray(); } int iLine = 0; foreach (var item in textSplit) { int i = item.IndexOfAny(new char[] { '(', ' ' }); string s = i == -1 ? item : item.Substring(0, i + 1); if ((start ? epFind.FindPattern(s) : epFind.FindPattern(s, (int)vsFindOptions.vsFindOptionsBackwards)) && (start ? epFind.LessThan(epEnd) : epFind.GreaterThan(epStart)) && (iLine == 0 || iLine == epFind.Line - (start ? 1 : -1))) { if (iLine == 0) { epFindStart = epFind.CreateEditPoint(); } iLine = epFind.Line; if (start) { epFind.EndOfLine(); } } else { return(false); } } return(true); } void Delete() { if (epFind.GreaterThan(epFindStart)) { epFind.LineDown(1); } else { epFindStart.LineDown(1); } epFind.StartOfLine(); epFindStart.StartOfLine(); epFindStart.Delete(epFind); } if (!Find(value.CSEnterText(), true)) { return(false); } else if (bDelete) { Delete(); } if (!Find(value.CSExitText(), false)) { return(false); } else if (bDelete) { Delete(); } else { return(true); } if (Find(value.CSCatchText(), false) && bDelete) { Delete(); } //格式化指定范围内的文本 value.StartPoint.CreateEditPoint().SmartFormat(value.EndPoint); return(true); }
protected bool AddMemberElementsFromType(CodeType ct, CodeClass synchClass) { string indexerParamList = ""; foreach (CodeElement member in ct.Members) { CodeFunction cf = member as CodeFunction; if (!AddSynchWrapperMember(synchClass, cf)) { return(false); } CodeProperty cp = member as CodeProperty; if (cp != null) { string getter = ""; string setter = ""; //Getter and Setter throw if property lacks these methods try{ if (cp.Getter != null) { getter = cp.Name; } }catch (Exception) {} try{ if (cp.Setter != null) { setter = cp.Name; } }catch (Exception) {} CodeFunction spSetter = null; if (cp.Name != "SyncRoot") { CodeProperty sp = synchClass.AddProperty(getter, setter, cp.Type, -1, cp.Access, null); TextRanges tr = null; bool hasGetter = false; sp.StartPoint.CreateEditPoint().ReplacePattern(sp.EndPoint, sp.Type.AsString, "override " + sp.Type.AsString, (int)EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord, ref tr); if (getter != "") { hasGetter = true; if (cp.Name != "IsSynchronized") { AddOneLineImpl(sp.Type.AsString + " ret;\nSystem.Threading.Monitor.Enter(_root);" + "\ntry{\nret = _parent." + getter + ";\n}\nfinally{System.Threading.Monitor.Exit(_root);}" + "\nreturn ret;", sp.Getter, true); } else { AddOneLineImpl("return true;", sp.Getter, true); } } if (setter != "") { //bug work-around foreach (CodeElement codeElm in synchClass.Members) { if (codeElm.Name == sp.Name) { spSetter = ((CodeProperty)codeElm).Setter; } } AddOneLineImpl("\nSystem.Threading.Monitor.Enter(_root);" + "\ntry{\n _parent." + setter + " = value;\n}\nfinally{System.Threading.Monitor.Exit(_root);}", spSetter, false); } if (cp.Name == "this") //fix up indexer override //add parameters { CodeFunction getterOrSetter; if (hasGetter) { getterOrSetter = cp.Getter; } else { getterOrSetter = cp.Setter; } System.Text.StringBuilder paramList = new System.Text.StringBuilder(); System.Text.StringBuilder paramListNoTypes = new System.Text.StringBuilder(); bool first = true; foreach (CodeParameter p in cp.Getter.Parameters) { if (!first) { paramListNoTypes.Append(", "); paramList.Append(", "); } first = false; paramList.Append(p.Type.AsString); paramList.Append(" "); paramList.Append(p.Name); paramListNoTypes.Append(p.Name); } EditPoint firstLine = sp.StartPoint.CreateEditPoint(); EditPoint secondLine = sp.StartPoint.CreateEditPoint(); TextPoint endPt = sp.EndPoint; secondLine.LineDown(1); secondLine.StartOfLine(); TextRanges tr1 = null; firstLine.ReplacePattern(secondLine, "this", "this[" + paramList.ToString() + "]", (int)EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord, ref tr1); //calls - replace .this with [param1, param2] paramListNoTypes.Insert(0, '['); paramListNoTypes.Append("]"); indexerParamList = paramListNoTypes.ToString(); } } } if (indexerParamList != "") { TextRanges tr = null; synchClass.StartPoint.CreateEditPoint().ReplacePattern( synchClass.EndPoint, ".this", indexerParamList, (int)EnvDTE.vsFindOptions.vsFindOptionsMatchCase, ref tr); } } return(true); }
/// <summary> /// Help method to modify KeyinCommands.cs or KeyinCommands.vb. /// </summary> /// <param name="projectItem"></param> /// <param name="keyinCommandFunctionCS"></param> /// <param name="keyinCommandFunctionvb"></param> private void ModifyKeyinsCommands(ProjectItem projectItem, string keyinCommandFunctionCS, string keyinCommandFunctionvb, string keyinCommandFunctionCPP) { Document activeDoc = projectItem.Document; if (activeDoc == null) { return; } ProjectItem activeDocumentProjectItem = activeDoc.ProjectItem; if (activeDocumentProjectItem == null) { return; } FileCodeModel fileCodeModel = activeDocumentProjectItem.FileCodeModel; if (fileCodeModel == null) { return; } CodeElements codeElements = fileCodeModel.CodeElements; CodeClass codeClass = null; // look for the namespace in the active document CodeNamespace codeNamespace = null; foreach (CodeElement codeElement in codeElements) { if (codeElement.Kind == vsCMElement.vsCMElementNamespace) { codeNamespace = codeElement as CodeNamespace; break; } } if (codeNamespace == null) { if (IsVBProject) { codeElements = fileCodeModel.CodeElements; } else { return; } } else { codeElements = codeNamespace.Members; } if (codeElements == null) { return; } // look for the first class foreach (CodeElement codeElement in codeElements) { if (codeElement.Kind == vsCMElement.vsCMElementClass) { codeClass = codeElement as CodeClass; break; } } if (codeClass == null) { return; } if (IsCSProject) { CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); EditPoint objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(6, "public static", 0); editPoint.Insert ( keyinCommandFunctionCS ); editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } else if (IsVBProject) { CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionSub, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); EditPoint objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(6, "Public Shared", 0); editPoint.Insert ( keyinCommandFunctionvb ); editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } else if (IsVCProject) { TextDocument editDoc = (TextDocument)activeDoc.Object("TextDocument"); EditPoint objEditPt = editDoc.CreateEditPoint(); EditPoint objMovePt = editDoc.EndPoint.CreateEditPoint(); objEditPt.StartOfDocument(); activeDoc.ReadOnly = false; if (objEditPt.FindPattern("#include")) { objEditPt.LineDown(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } else if ((objEditPt.FindPattern("#using"))) { objEditPt.LineUp(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } else { objEditPt.FindPattern("namespace"); objEditPt.LineUp(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", "System::String^", -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(4, "public:static", 0); editPoint.Insert(keyinCommandFunctionCPP); if (objEditPt.FindPattern("throw gcnew System::NotImplementedException();")) { editPoint.Delete(52); } editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } }