private bool Evaluate(out object newValue)
{
newValue = null;
CodeClass currentDSAClass = ExpressionEvaluationHelper.EvaluateExpression((IDictionaryService)GetService(typeof(IDictionaryService)),
currentDSAClassExpression) as CodeClass;
if (currentDSAClass != null)
{
CodeProperty onlineProxyTypeProperty = CodeModelHelper.GetProperty(currentDSAClass, "OnlineProxyType", vsCMAccess.vsCMAccessPublic);
if (onlineProxyTypeProperty != null)
{
CodeFunction getMethod = onlineProxyTypeProperty.Getter;
EditPoint edit = getMethod.StartPoint.CreateEditPoint();
EditPoint endpoint = null;
TextRanges tags = null;
if (edit.FindPattern(@"(typeof|GetType)\((.+)\)", (int)vsFindOptions.vsFindOptionsRegularExpression, ref endpoint, ref tags))
{
EditPoint begin = edit.CreateEditPoint();
string proxyTypeName = begin.GetText(endpoint);
Regex extractRegex = new Regex(@"(typeof|GetType)\((.+)\)");
if (extractRegex.IsMatch(proxyTypeName) && extractRegex.Match(proxyTypeName).Groups.Count == 3)
{
proxyTypeName = extractRegex.Match(proxyTypeName).Groups[2].Value;
newValue = proxyTypeName;
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Finds a pattern in the specified range of text and replaces it with the specified text.
/// </summary>
/// <param name="startPoint">The start point of the specified range of text.</param>
/// <param name="endPoint">The end point of the specified range of text.</param>
/// <param name="oldText">The text to replace.</param>
/// <param name="newText">The replacement text for pattern.</param>
public bool Replace(TextPoint startPoint, TextPoint endPoint, string oldText, string newText)
{
EditPoint ep = Document.CreateEditPoint(startPoint);
TextRanges tr = null;
return(ep.ReplacePattern(endPoint, oldText, newText,
(int)vsFindOptions.vsFindOptionsMatchWholeWord, ref tr));
}
private bool Find(EditPoint2 editPoint,
string text)
{
EditPoint endPoint = null;
TextRanges tags = null;
return(editPoint.FindPattern(text, (int)vsFindOptions.vsFindOptionsMatchInHiddenText,
ref endPoint, ref tags));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Moves the up before comment.
/// </summary>
/// <param name="sel">The sel.</param>
/// ------------------------------------------------------------------------------------
private void MoveUpBeforeComment(TextSelection sel)
{
TextRanges textRanges = null;
for (; true;)
{
if (sel.FindPattern("\\<summary\\>|/// ---", (int)(vsFindOptions.vsFindOptionsBackwards | vsFindOptions.vsFindOptionsRegularExpression),
ref textRanges))
{
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// ---"))
{
sel.EndOfLine(true);
sel.WordRight(true, 1);
sel.Delete(1);
}
else if (sel.Text.StartsWith("<summary>"))
{
while (true)
{
sel.MoveToLineAndOffset(sel.ActivePoint.Line - 1, 1, false);
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
sel.EndOfLine(true);
if (!sel.Text.StartsWith("///"))
{
if (sel.Text.Length > 0)
{
// there is a non-empty comment line. We want to start at the end
// of it
sel.EndOfLine(false);
}
else
{
sel.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstText, false);
}
break;
}
// GhostDoc messes up dashed lines from inherited comments from base class,
// so delete those
if (sel.Text.StartsWith("/// -----"))
{
sel.WordRight(true, 1);
sel.Delete(1);
}
}
return;
}
}
else
{
return;
}
}
}
/// <summary>
/// Finds a pattern in the specified range of text and replaces it with the specified text.
/// </summary>
/// <param name="startLine">The start line of the specified range of text.</param>
/// <param name="startRow">The start row of the specified range of text.</param>
/// <param name="endLine">The end line of the specified range of text.</param>
/// <param name="endRow">The end row of the specified range of text.</param>
/// <param name="oldText">The text to replace.</param>
/// <param name="newText">The replacement text for pattern.</param>
public bool Replace(int startLine, int startRow, int endLine, int endRow, string oldText, string newText)
{
EditPoint ep = Document.CreateEditPoint(new LuaTextPoint(Document, startRow, startLine));
TextRanges tr = null;
TextPoint endTextPoint = new LuaTextPoint(Document, endRow, endLine);
//Trace.WriteLine(string.Format("Start: {0} - End: {1}", new LuaTextPoint(Document, startRow, startLine),endTextPoint));
return(ep.ReplacePattern(endTextPoint, oldText, newText,
(int)vsFindOptions.vsFindOptionsMatchWholeWord, ref tr));
}
/// <summary>Finds all instances of a text in the document object for the provided item.</summary>
/// <param name="item">Project item to search texts</param>
/// <param name="text">Text to look for</param>
/// <returns>A collection of BaseHardCodedString objects that references to text</returns>
public static ReadOnlyCollection <BaseHardCodedString> FindAllInstancesInDocument(ProjectItem item, string text)
{
TextDocument doc = GetDocumentForItem(item);
Collection <BaseHardCodedString> instances = new Collection <BaseHardCodedString>();
EditPoint start = doc.StartPoint.CreateEditPoint();
start.MoveToAbsoluteOffset(1);
EditPoint end = null;
// Unused object for FindPattern method.
TextRanges ranges = null;
System.Collections.IEnumerator comments = null;
Match currentMatch = null;
BaseHardCodedString instance = BaseHardCodedString.GetHardCodedString(item.Document);
while (start.FindPattern(text, (int)(vsFindOptions.vsFindOptionsMatchCase), ref end, ref ranges))
{
if (instance != null)
{
if (comments == null)
{
comments = instance.FindCommentsInDocument(item).GetEnumerator();
}
bool inComment = false;
while (currentMatch != null || (comments.MoveNext()))
{
currentMatch = (Match)(comments.Current);
// If this match appears earlier then current text skip
if (currentMatch.Index + currentMatch.Length <= (start.AbsoluteCharOffset - 1))
{
currentMatch = null;
}
// If this comment is later then current text stop processing comments
else if (currentMatch.Index >= (end.AbsoluteCharOffset - 1))
{
break;
}
// At this point current text must be part of a comment block
else
{
inComment = true;
break;
}
}
if (!inComment)
{
instance = instance.CreateInstance(item, start.AbsoluteCharOffset - 1, end.AbsoluteCharOffset - 1);
instances.Add(instance);
}
}
start = end;
}
return(new ReadOnlyCollection <BaseHardCodedString>(instances));
}
private EditPoint FindFirstMatch(EditPoint startPoint, string pattern)
{
EditPoint endPoint = null;
TextRanges tags = null;
if (startPoint != null && startPoint.FindPattern(pattern, (int)(vsFindOptions.vsFindOptionsRegularExpression | vsFindOptions.vsFindOptionsMatchInHiddenText), ref endPoint, ref tags))
{
return(startPoint.CreateEditPoint());
}
return(null);
}
public void RemoveRegions(Proc replaceString)
{
Document currentDocument = _applicationObject.ActiveDocument;
TextDocument currentTextDocument = currentDocument.Object("") as TextDocument;
TextSelection txtSel = (TextSelection)_applicationObject.ActiveDocument.Selection;
if (currentTextDocument != null)
{
TextRanges refRanges = null;
if (currentTextDocument.Language == "CSharp")
{
try
{
txtSel.SelectAll();
txtSel.ReplacePattern(replaceString(), " ",
(int)vsFindOptions.vsFindOptionsFromStart +
(int)vsFindOptions.vsFindOptionsMatchInHiddenText +
(int)vsFindOptions.vsFindOptionsKeepModifiedDocumentsOpen +
(int)vsFindOptions.vsFindOptionsRegularExpression,
ref refRanges);
//currentTextDocument.ReplacePattern(replaceString(), string.Empty,
// (int) vsFindOptions.vsFindOptionsFromStart +
// (int) vsFindOptions.vsFindOptionsMatchInHiddenText +
// (int) vsFindOptions.vsFindOptionsKeepModifiedDocumentsOpen +
// (int) vsFindOptions.vsFindOptionsRegularExpression,
// ref refRanges);
}
catch (Exception e)
{
Console.Out.WriteLine("e = {0}", e);
}
}
#region some other crap
#region inner region
# region
#endregion
#endregion
#endregion
#region
#endregion
}
}
/// <summary>
/// Gets the text between the specified start point and the first match.
/// </summary>
/// <param name="startPoint">The start point.</param>
/// <param name="matchString">The match string.</param>
/// <returns>The matching text, otherwise null.</returns>
internal static string GetTextToFirstMatch(TextPoint startPoint, string matchString)
{
var startEditPoint = startPoint.CreateEditPoint();
var endEditPoint = startEditPoint.CreateEditPoint();
TextRanges subGroupMatches = null; // Not used - required for FindPattern.
if (endEditPoint.FindPattern(matchString, StandardFindOptions, ref endEditPoint, ref subGroupMatches))
{
return(startEditPoint.GetText(endEditPoint));
}
return(null);
}
/// <summary>
/// Finds the first match of the specified pattern within the specified text document, otherwise null.
/// </summary>
/// <param name="textDocument">The text document.</param>
/// <param name="patternString">The pattern string.</param>
/// <returns>The first match, otherwise null.</returns>
internal static EditPoint FirstOrDefaultMatch(TextDocument textDocument, string patternString)
{
var cursor = textDocument.StartPoint.CreateEditPoint();
EditPoint end = null;
TextRanges dummy = null;
if (cursor != null && cursor.FindPattern(patternString, StandardFindOptions, ref end, ref dummy))
{
return(cursor.CreateEditPoint());
}
return(null);
}
private List <EditPoint> FindAll(TextDocument doc, string toFind)
{
var matches = new List <EditPoint>();
var cursor = doc.StartPoint.CreateEditPoint();
EditPoint end = null;
TextRanges dummy = null;
while (cursor != null && cursor.FindPattern(toFind, standardFindOptions, ref end, ref dummy))
{
matches.Add(cursor.CreateEditPoint());
cursor = end;
}
return(matches);
}
/// <summary>
/// Finds all matches of the specified pattern within the specified text document.
/// </summary>
/// <param name="textDocument">The text document.</param>
/// <param name="patternString">The pattern string.</param>
/// <returns>The set of matches.</returns>
internal static IEnumerable <EditPoint> FindMatches(TextDocument textDocument, string patternString)
{
var matches = new List <EditPoint>();
var cursor = textDocument.StartPoint.CreateEditPoint();
EditPoint end = null;
TextRanges dummy = null;
while (cursor != null && cursor.FindPattern(patternString, StandardFindOptions, ref end, ref dummy))
{
matches.Add(cursor.CreateEditPoint());
cursor = end;
}
return(matches);
}
private bool GetIncludeInfo(ref string path)
{
//first we need to find the text thing
Document doc = App().ActiveDocument;
if (doc != null)
{
TextDocument text = (TextDocument)doc.Object("");
//this is the current selection's top line #
int line = text.Selection.CurrentLine;
int col = text.Selection.CurrentColumn;
VirtualPoint activepoint = text.Selection.ActivePoint;
EditPoint point = activepoint.CreateEditPoint();
point.EndOfLine();
EditPoint endfound = null;
TextRanges found = null;
bool result = point.FindPattern("opinclude[ \t]+\\\"{.*}\\\"", (int)(vsFindOptions.vsFindOptionsBackwards | vsFindOptions.vsFindOptionsRegularExpression), ref endfound, ref found);
if (result)
{
int foundline = endfound.Line;
//NOTE: I think this is correct...
int offset = line - foundline - 1; //TODO: get this 1 to be constant in macro expansion!
TextRange fullmatch = found.Item(1);
// need to break out if the active point wasn't in the line
if (fullmatch.StartPoint.Line != activepoint.Line)
{
return(false);
}
TextRange filematch = found.Item(2);
string filetext = filematch.StartPoint.GetText(filematch.EndPoint);
//NOTE: this returns what was in the opinclude, but does not resolve the path
path = filetext;
return(true);
}
}
return(false);
}
/// <summary>
/// aspx页面中关于搜索条件样式替换
/// </summary>
/// <param name="textDocument"></param>
/// <param name="patternString"></param>
internal void PrcoessWhere(TextDocument textDocument, string patternString)
{
var cursor = textDocument.StartPoint.CreateEditPoint();
EditPoint end = null;
TextRanges dummy = null;
while (cursor != null && cursor.FindPattern(patternString, (int)vsFindOptions.vsFindOptionsRegularExpression, ref end, ref dummy))
{
EditPoint startPoint = cursor.CreateEditPoint();
//matches.Add(startPoint);
cursor = end;
string src = startPoint.GetText(end);
string replaceMent = "$1 CssClass=\"form-control\"${footer}";
startPoint.ReplacePattern(end, patternString, replaceMent, (int)vsFindOptions.vsFindOptionsRegularExpression);
}
}
/// <summary>
/// Retrieves a field from the project's assembly information.
/// </summary>
/// <param name="doc">The document object of the AssemblyInfo.cs file.</param>
/// <param name="assemblyInfoKey">The AssemblyInfo key to get the data for.</param>
/// <returns>The value of the field.</returns>
private string RetrieveAssemblyInfoValue(TextDocument doc, string assemblyInfoKey)
{
string assemblyInfoValue = string.Empty;
EditPoint startPoint = doc.StartPoint.CreateEditPoint();
EditPoint blockPoint = startPoint.CreateEditPoint();
TextRanges trs = null;
if (startPoint.FindPattern(string.Format(@"\[assembly\: {0}\("".*""\)\]", assemblyInfoKey), (int)vsFindOptions.vsFindOptionsRegularExpression, ref blockPoint, ref trs))
{
startPoint.StartOfLine();
blockPoint.EndOfLine();
assemblyInfoValue = startPoint.GetText(blockPoint).Trim();
}
return(Regex.Match(assemblyInfoValue, @""".*""").Value);
}
/// <summary>
/// Substitutes all occurrences in the specified text document of
/// the specified pattern string with the specified replacement string.
/// </summary>
/// <param name="textDocument">The text document.</param>
/// <param name="patternString">The pattern string.</param>
/// <param name="replacementString">The replacement string.</param>
internal static void SubstituteAllStringMatches(this TextDocument textDocument, string patternString, string replacementString)
{
TextRanges dummy = null;
var lastCount = -1;
while (textDocument.ReplacePattern(patternString, replacementString, StandardFindOptions, ref dummy))
{
// it is possible that the replacements aren't actually being done. In such a case, we can
// detect the situation by seeing if the count always remains the same, and if so exiting early.
if (lastCount == dummy.Count)
{
OutputWindowHelper.WriteLine("EditorConfig had to force a break out of TextDocumentHelper's SubstituteAllStringMatches for a document.");
break;
}
lastCount = dummy.Count;
}
}
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;
}
}
/// <summary>
/// 查找代码
/// </summary>
/// <param name="win"></param>
/// <param name="pattern"></param>
/// <returns></returns>
public static string FindCode(Window win, string pattern)
{
var doc = (TextDocument)win.Document.Object("TextDocument");
EditPoint editPoint = doc.StartPoint.CreateEditPoint();
EditPoint endPoint = null;
TextRanges tags = null;
bool find = editPoint.FindPattern(pattern, (int)(vsFindOptions.vsFindOptionsFromStart |
vsFindOptions.vsFindOptionsRegularExpression), ref endPoint, ref tags);
if (find && tags != null)
{
return(editPoint.GetText(endPoint));
}
return("");
}
/// <summary>
/// Substitutes all occurrences between the specified start and end points of the specified
/// pattern string with the specified replacement string.
/// </summary>
/// <param name="startPoint">The start point.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="patternString">The pattern string.</param>
/// <param name="replacementString">The replacement string.</param>
internal static void SubstituteAllStringMatches(EditPoint startPoint, EditPoint endPoint, string patternString, string replacementString)
{
TextRanges dummy = null;
int lastCount = -1;
while (startPoint.ReplacePattern(endPoint, patternString, replacementString, StandardFindOptions, ref dummy))
{
// it is possible that the replacements aren't actually being done. In such a case,
// we can detect the situation by seeing if the count always remains the same, and
// if so exiting early.
if (lastCount == dummy.Count)
{
OutputWindowHelper.WarningWriteLine("Forced a break out of TextDocumentHelper's SubstituteAllStringMatches for a pair of points.");
break;
}
lastCount = dummy.Count;
}
}
public static void Execute(ProjectItem projectItem)
{
string textToInsert = string.Format(Text, projectItem.Name);
var objTextDoc = (TextDocument)projectItem.Document.Object("TextDocument");
EditPoint editPoint = objTextDoc.StartPoint.CreateEditPoint();
while (string.IsNullOrWhiteSpace(editPoint.GetLineText()))
{
editPoint.DeleteCurrentLine();
}
if (projectItem.ReadAllText().TrimStart().StartsWith(textToInsert, StringComparison.InvariantCulture))
{
return;
}
var txtSel = (TextSelection)projectItem.Document.Selection;
txtSel.MoveTo(0, 0);
TextRanges ranges = null;
int findOptions = (int)(vsFindOptions.vsFindOptionsRegularExpression | vsFindOptions.vsFindOptionsFromStart);
if (txtSel.FindPattern(RegExText, findOptions, ref ranges))
{
var firstRange = ranges.OfType <TextRange>().FirstOrDefault();
if (firstRange != null)
{
var rangeText = firstRange.StartPoint.GetText(firstRange.EndPoint);
if (rangeText.Trim().Equals(textToInsert.Trim(), StringComparison.InvariantCulture))
{
return;
}
firstRange.StartPoint.Delete(firstRange.EndPoint);
}
}
txtSel.GotoLine(1, true);
txtSel.StartOfLine();
txtSel.NewLine();
txtSel.GotoLine(1, true);
txtSel.Insert(textToInsert);
}
private static void MoveCodeBlock(CodeElement parent, CodeElement block, EditPoint pastePoint)
{
EditPoint blockStartPoint = block.StartPoint.CreateEditPoint();
EditPoint previousblockEndPoint = blockStartPoint.CreateEditPoint();
EditPoint editPoint = blockStartPoint.CreateEditPoint();
TextRanges trs = null;
if (editPoint.FindPattern("}", (int)vsFindOptions.vsFindOptionsBackwards, ref previousblockEndPoint, ref trs))
{
if (previousblockEndPoint.GreaterThan(parent.StartPoint))
{
blockStartPoint = previousblockEndPoint;
}
}
blockStartPoint.Cut(block.EndPoint, false);
pastePoint.Paste();
pastePoint.Insert("\r\n\r\n");
}
/// <summary>mark the method and bring the Visual Studio on front</summary>
/// <param term='codeFunction'>is the right codeFunction element to the searched method</param>
/// <param name="methodString">name of the method</param>
internal void markMethod(CodeFunction codeFunction)
{
dte.Documents.Open(codeFunction.ProjectItem.get_FileNames(0), "Auto", false);
TextSelection textSelection = (TextSelection)dte.ActiveDocument.Selection;
textSelection.MoveToLineAndOffset(codeFunction.StartPoint.Line, codeFunction.StartPoint.LineCharOffset, false);
TextRanges textRanges = null;
string pattern = @"[:b]<{" + codeFunction.Name + @"}>[:b(\n]";
if (textSelection.FindPattern(pattern, (int)vsFindOptions.vsFindOptionsRegularExpression, ref textRanges))
{
TextRange r = textRanges.Item(2);
textSelection.MoveToLineAndOffset(r.StartPoint.Line, r.StartPoint.LineCharOffset, false);
textSelection.MoveToLineAndOffset(r.EndPoint.Line, r.EndPoint.LineCharOffset, true);
}
dte.MainWindow.Activate();
}
/// <summary>
/// 匹配方法
/// </summary>
/// <returns></returns>
private bool toFunc(Window win)
{
// 匹配方法定义代码（vs的正则表达式有点特殊）
string pattern = @":a_ \.\<\>\[\]\t\n";
switch (_serviceFunc.ParamNum)
{
// -1不匹配参数个数
case -1:
pattern = string.Format(@"public :c+ {0}\([^\)]*\)", _serviceFunc.Func);
break;
case 0:
pattern = string.Format(@"public :c+ {0}\(\)", _serviceFunc.Func);
break;
case 1:
pattern = string.Format(@"public :c+ {1}\([{0}]+\)", pattern, _serviceFunc.Func);
break;
default:
pattern = string.Format(@"public :c+ {1}\(([{0}]+,)^{2}[{0}]+\)", pattern, _serviceFunc.Func, _serviceFunc.ParamNum - 1);
break;
}
var doc = (TextDocument)win.Document.Object("TextDocument");
EditPoint editPoint = doc.StartPoint.CreateEditPoint();
EditPoint endPoint = null;
TextRanges tags = null;
bool find = editPoint.FindPattern(pattern, (int)(vsFindOptions.vsFindOptionsFromStart |
vsFindOptions.vsFindOptionsRegularExpression), ref endPoint, ref tags);
if (find && tags != null)
{
doc.Selection.MoveToPoint(endPoint, false);
doc.Selection.MoveToPoint(editPoint, true);
}
return(find);
}
/// <summary>
/// Finds all matches of the specified pattern within the specified text selection.
/// </summary>
/// <param name="textSelection">The text selection.</param>
/// <param name="patternString">The pattern string.</param>
/// <returns>The set of matches.</returns>
internal static IEnumerable <EditPoint> FindMatches(TextSelection textSelection, string patternString)
{
var matches = new List <EditPoint>();
var cursor = textSelection.TopPoint.CreateEditPoint();
EditPoint end = null;
TextRanges dummy = null;
while (cursor != null && cursor.FindPattern(patternString, StandardFindOptions, ref end, ref dummy))
{
if (end.AbsoluteCharOffset > textSelection.BottomPoint.AbsoluteCharOffset)
{
break;
}
matches.Add(cursor.CreateEditPoint());
cursor = end;
}
return(matches);
}
/// <summary>
/// Gets a list of insertion points.
/// </summary>
/// <param name="fileCodeModel">The code model to search.</param>
/// <returns>A list of insertion points.</returns>
private List <EditPoint> GetInsertionPoints(FileCodeModel fileCodeModel)
{
List <EditPoint> namespacePoints = new List <EditPoint>();
for (int i = 1; i <= fileCodeModel.CodeElements.Count; i++)
{
if (fileCodeModel.CodeElements.Item(i).Kind == vsCMElement.vsCMElementNamespace)
{
EditPoint namespacePoint = fileCodeModel.CodeElements.Item(i).StartPoint.CreateEditPoint();
TextRanges trs = null;
if (namespacePoint.FindPattern("{", (int)vsFindOptions.vsFindOptionsMatchCase, ref namespacePoint, ref trs))
{
namespacePoints.Add(namespacePoint);
}
}
}
return(namespacePoints);
}
/// <summary>
/// Gets the code block for a given element, this includes any comments that come before the element,
/// but after the previous element.
/// </summary>
/// <param name="parent">The current block's parent.</param>
/// <param name="block">The current block.</param>
/// <param name="newStartPoint">The starting point used to capture the beginning of the element.</param>
/// <returns>The text of a given block.</returns>
private string GetCodeBlockText(CodeElement parent, CodeElement block, out EditPoint newStartPoint)
{
EditPoint blockStartPoint = block.StartPoint.CreateEditPoint();
EditPoint previousblockEndPoint = blockStartPoint.CreateEditPoint();
EditPoint editPoint = blockStartPoint.CreateEditPoint();
TextRanges trs = null;
if (editPoint.FindPattern("}", (int)vsFindOptions.vsFindOptionsBackwards, ref previousblockEndPoint, ref trs))
{
if (previousblockEndPoint.GreaterThan(parent.StartPoint))
{
blockStartPoint = previousblockEndPoint;
}
else
{
previousblockEndPoint = blockStartPoint.CreateEditPoint();
editPoint = blockStartPoint.CreateEditPoint();
if (editPoint.FindPattern("{", (int)vsFindOptions.vsFindOptionsBackwards, ref previousblockEndPoint, ref trs))
{
if (previousblockEndPoint.GreaterThan(parent.StartPoint))
{
blockStartPoint = previousblockEndPoint;
}
}
}
}
else
{
if (editPoint.FindPattern("{", (int)vsFindOptions.vsFindOptionsBackwards, ref previousblockEndPoint, ref trs))
{
if (previousblockEndPoint.GreaterThan(parent.StartPoint))
{
blockStartPoint = previousblockEndPoint;
}
}
}
newStartPoint = blockStartPoint.CreateEditPoint();
return(blockStartPoint.GetText(block.EndPoint).Trim());
}
/// <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"))
{
try
{
TextDocument projectItemDoc = (TextDocument)ideWindow.Document.Object("TextDocument");
EditPoint startPoint = projectItemDoc.StartPoint.CreateEditPoint();
EditPoint blockPoint = startPoint.CreateEditPoint();
TextRanges trs = null;
bool found = blockPoint.FindPattern("<copyright", (int)vsFindOptions.vsFindOptionsMatchCase, ref blockPoint, ref trs);
if (!found || blockPoint.Line > 2)
{
Debug.WriteLine("Finding assembly info...");
ProjectItem assemblyInfo = projectItem.DTE.Solution.FindProjectItem("AssemblyInfo.cs");
TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument");
assemblyInfo.Open(EnvDTE.Constants.vsViewKindTextView).Activate();
TextDocument assemblyDoc = (TextDocument)assemblyInfo.DTE.ActiveWindow.Document.Object("TextDocument");
string company = RetrieveAssemblyInfoValue(assemblyDoc, "AssemblyCompany");
string copyright = RetrieveAssemblyInfoValue(assemblyDoc, "AssemblyCopyright");
string fileName = projectItem.Name;
Debug.WriteLine("Adding Copyright to file: " + projectItem.Name);
AddCopyrightToFile(projectItemDoc, fileName, company, copyright);
}
else
{
Debug.WriteLine("Copyright detected, skipping copyright header.");
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.ToString());
Debug.WriteLine("Format failed, skipping");
}
}
}
/// <summary>
/// Updates the #endregion directives to match the names of the matching #region directive
/// and cleans up any unnecessary white space.
/// </summary>
/// <remarks>
/// This code is very similar to the Common region retrieval function, but since it
/// manipulates the cursors during processing the logic is different enough to warrant a
/// separate copy of the code.
/// </remarks>
/// <param name="textDocument">The text document to cleanup.</param>
internal void UpdateEndRegionDirectives(TextDocument textDocument)
{
if (!Settings.Default.Cleaning_UpdateEndRegionDirectives)
{
return;
}
var regionStack = new Stack <string>();
EditPoint cursor = textDocument.StartPoint.CreateEditPoint();
TextRanges subGroupMatches = null; // Not used - required for FindPattern.
const string pattern = @"^[ \t]*#";
// Keep pushing cursor forwards (note ref cursor parameter) until finished.
while (cursor != null &&
cursor.FindPattern(pattern, TextDocumentHelper.StandardFindOptions, ref cursor, ref subGroupMatches))
{
// Create a pointer to capture the text for this line.
EditPoint eolCursor = cursor.CreateEditPoint();
eolCursor.EndOfLine();
string regionText = cursor.GetText(eolCursor);
if (regionText.StartsWith("region ")) // Space required by compiler.
{
// Cleanup any whitespace in the region name.
string regionName = regionText.Substring(7);
string regionNameTrimmed = regionName.Trim();
if (regionName != regionNameTrimmed)
{
cursor.CharRight(7);
cursor.Delete(eolCursor);
cursor.Insert(regionNameTrimmed);
}
// Push the parsed region name onto the top of the stack.
regionStack.Push(regionNameTrimmed);
}
else if (regionText.StartsWith("endregion")) // Space may or may not be present.
{
if (regionStack.Count > 0)
{
// Do not trim the endRegionName in order to catch whitespace differences.
string endRegionName = regionText.Length > 9 ?
regionText.Substring(10) : String.Empty;
string matchingRegion = regionStack.Pop();
// Update if the strings do not match.
if (matchingRegion != endRegionName)
{
cursor.CharRight(9);
cursor.Delete(eolCursor);
cursor.Insert(" " + matchingRegion);
}
}
else
{
// This document is improperly formatted, abort.
return;
}
}
// Note: eolCursor may be outdated now if changes have been made.
cursor.EndOfLine();
}
}
public bool ReplacePattern(string Pattern, string Replace, int vsFindOptionsValue, ref TextRanges Tags)
{
throw new NotImplementedException();
}
void UpdateArguments()
{
Document doc = App().ActiveDocument;
//whats the xml file's path?
string xmlpath = "";
bool available = UpdateXml(ref xmlpath);
if (!available)
{
Arguments.Clear();
return;
}
TextDocument text = (TextDocument)doc.Object("");
VirtualPoint currentpoint = text.Selection.ActivePoint;
EditPoint point = currentpoint.CreateEditPoint();
point.EndOfLine();
EditPoint endfound = null;
TextRanges found = null;
Arguments.Clear();
bool result = point.FindPattern("note[ \t]+{.*}\\({.*}\\)", (int)(vsFindOptions.vsFindOptionsBackwards | vsFindOptions.vsFindOptionsRegularExpression), ref endfound, ref found);
if (result)
{
TextRange fullmatch = found.Item(1);
TextRange pathmatch = found.Item(2);
TextRange argmatch = found.Item(3);
//only want it if the point was in the range
if (fullmatch.EndPoint.LessThan(currentpoint) ||
fullmatch.StartPoint.GreaterThan(currentpoint))
{
return;
}
ArgumentEnd = argmatch.EndPoint;
string arguments = argmatch.StartPoint.GetText(argmatch.EndPoint).Trim();
NoteArguments = arguments.Split(',');
string notepath = pathmatch.StartPoint.GetText(pathmatch.EndPoint).Trim();
XmlNoteNode note = XmlFile.GetNote(notepath);
if (note != null)
{
Arguments = new List <string>();
foreach (XmlArgumentNode n in note.Arguments)
{
Arguments.Add(n.Name);
}
}
}
}
protected bool AddSynchWrapperMember(CodeClass synch, CodeFunction cf)
{
if (cf != null && (cf.FunctionKind & FunctionsThatCantBeAnnotatedAsVirtual) == 0 &&
cf.CanOverride == true && cf.IsShared == false)
{
//add prototype and parameters
CodeFunction synchFunction = synch.AddFunction(cf.Name, cf.FunctionKind, cf.Type, -1, cf.Access, null);
foreach (CodeParameter param in cf.Parameters)
{
synchFunction.AddParameter(param.Name, param.Type, -1);
}
synchFunction.CanOverride = true;
EditPoint replaceVirtual = synchFunction.StartPoint.CreateEditPoint();
TextRanges tr = null;
replaceVirtual.ReplacePattern(synchFunction.EndPoint, "virtual", "override",
(int)EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord, ref tr);
//remove default return
EditPoint editPt = synchFunction.EndPoint.CreateEditPoint();
editPt.LineUp(1);
editPt.StartOfLine();
string returnType = cf.Type.AsString;
if (returnType != "void")
{
EditPoint startOfLastLine = synchFunction.EndPoint.CreateEditPoint();
startOfLastLine.LineUp(1);
startOfLastLine.EndOfLine();
editPt.Delete(startOfLastLine);
}
//generate method body
System.Text.StringBuilder methodBody = new System.Text.StringBuilder(100);
if (returnType != "void")
{
methodBody.Append(cf.Type.AsString + " ret;\n");
}
methodBody.Append(
"System.Threading.Monitor.Enter(_root);" +
"\ntry{");
if (returnType != "void")
{
methodBody.Append("\nret = _parent." + cf.Name + "(");
}
else
{
methodBody.Append("\n_parent." + cf.Name + "(");
}
bool first = true;
foreach (CodeParameter p in cf.Parameters)
{
if (!first)
{
methodBody.Append(", ");
}
first = false;
int typeSpaceLocation = p.Type.AsString.IndexOf(' ');
if (typeSpaceLocation != -1) //append out or ref to parameter
{
methodBody.Append(p.Type.AsString.Substring(0, typeSpaceLocation + 1));
}
methodBody.Append(p.Name);
}
methodBody.Append(");");
methodBody.Append(
"\n}" +
"\nfinally{System.Threading.Monitor.Exit(_root);}");
if (returnType != "void")
{
methodBody.Append("\nreturn ret;");
}
//add new body to method
editPt.Insert(methodBody.ToString());
editPt.MoveToPoint(synchFunction.StartPoint);
editPt.SmartFormat(synchFunction.EndPoint);
}
return(true);
}
