static private bool AtLineEndIgnoringWhiteSpace(
EnvDTE.EditPoint pt)
{
EnvDTE.EditPoint temp = pt.CreateEditPoint();
while ((!temp.AtEndOfLine) &&
((temp.GetText(1) == " ") ||
(temp.GetText(1) == "\t")))
{
temp.CharRight(1);
}
return(temp.AtEndOfLine);
}
/// <summary>
/// This actually removes the text or, if there are errors, logs them to the task list.
///
/// There are six cases to handle:
/// <no tags> -> true
/// <just a start> -> error
/// <just an end> -> error
/// <end> <start> -> error
/// <start> <start> -> error
/// <start> <end> -> success -- remove *and* proceed to loop again!
/// </summary>
/// <param name="TextDoc"> Document upon which to operate. </param>
/// <param name="currentPos"> The current position from which execution should proceed. </param>
/// <param name="begin"> String denoting the begin tag to find. </param>
/// <param name="end"> String denoting the end tag to find. </param>
/// <param name="linesRemoved"> Number of lines that have already been removed from the file. </param>
private bool ExtractTextHelper(EnvDTE.Document doc, EnvDTE.EditPoint currentPos, string begin, string end, EnvDTE.ProjectItems projSourceItems, int linesRemoved)
{
EnvDTE.EditPoint startTagPoint, endTagPoint, nextStartTagPoint;
EnvDTE.TextRanges trIgnore = null;
bool fGotStart, fGotEnd, fGotNextStart;
startTagPoint = currentPos.CreateEditPoint();
endTagPoint = currentPos.CreateEditPoint();
fGotStart = startTagPoint.FindPattern(begin, (int)EnvDTE.vsFindOptions.vsFindOptionsNone, ref startTagPoint, ref trIgnore);
fGotEnd = endTagPoint.FindPattern(end, (int)EnvDTE.vsFindOptions.vsFindOptionsNone, ref endTagPoint, ref trIgnore);
if (!fGotStart && !fGotEnd)
{
return(true);
}
if (fGotStart && !fGotEnd)
{
// Error, end tag expected after startTagPoint
string strError = AMResources.GetLocalizedString("TagValidationMissingEndAfter");
// m_taskWindow.LogErrorToTaskWindow(System.String.Format(strError, end),
// projSourceItems.Item(doc.Name).get_FileNames(1), startTagPoint.Line + linesRemoved);
return(false);
}
if (fGotEnd && !fGotStart)
{
// Error, start tag expected before endTagPoint
string strError = AMResources.GetLocalizedString("TagValidationMissingStartBefore");
// m_taskWindow.LogErrorToTaskWindow(System.String.Format(strError, begin),
// projSourceItems.Item(doc.Name).get_FileNames(1), endTagPoint.Line + linesRemoved);
return(false);
}
if (endTagPoint.AbsoluteCharOffset < startTagPoint.AbsoluteCharOffset)
{
// Error, start tag expected before endTagPoint
string strError = AMResources.GetLocalizedString("TagValidationMissingStartBefore");
// m_taskWindow.LogErrorToTaskWindow(System.String.Format(strError, begin),
// projSourceItems.Item(doc.Name).get_FileNames(1), endTagPoint.Line + linesRemoved);
return(false);
}
nextStartTagPoint = startTagPoint.CreateEditPoint();
fGotNextStart = nextStartTagPoint.FindPattern(begin, (int)EnvDTE.vsFindOptions.vsFindOptionsNone, ref nextStartTagPoint, ref trIgnore);
if (fGotNextStart && (endTagPoint.AbsoluteCharOffset > nextStartTagPoint.AbsoluteCharOffset))
{
// Error, end tag expected before endTagPoint
string strError = AMResources.GetLocalizedString("TagValidationMissingEndBefore");
// m_taskWindow.LogErrorToTaskWindow(System.String.Format(strError, end),
// projSourceItems.Item(doc.Name).get_FileNames(1), nextStartTagPoint.Line + linesRemoved);
return(false);
}
if (startTagPoint.AbsoluteCharOffset < endTagPoint.AbsoluteCharOffset)
{
linesRemoved += (endTagPoint.Line - startTagPoint.Line);
startTagPoint.CharLeft(begin.Length);
startTagPoint.Delete((object)endTagPoint);
return(ExtractTextHelper(doc, endTagPoint, begin, end, projSourceItems, linesRemoved));
}
System.Diagnostics.Debug.Assert(false, "Impossible code path followed in ExtractTextHelper()");
return(true);
}
static private void WrapBlock(
ParameterSet pset,
CommentBlock block,
MatchedBlockData bdata,
EnvDTE.TextPoint pt)
{
int blockTabSize = pt.Parent.TabSize;
if (!pset.mUseTabsToIndent)
{
blockTabSize = 0;
}
bool isInPreformmatedBlock = false;
bool isLastLine = false;
bool isStartOnSeparateLine = false;
EnvDTE.EditPoint curPoint = pt.CreateEditPoint();
curPoint.MoveToLineAndOffset(bdata.mStartLine, 1);
// seems we have to pick the reight line ending ourselves
string eol = "\r\n";
if (curPoint.GetText(-1).Length == 1)
{
eol = "\n";
}
EnvDTE.EditPoint endPoint = pt.CreateEditPoint();
endPoint.MoveToLineAndOffset(bdata.mEndLine, 1);
if ((block.mBlockEndType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) ||
(block.mBlockEndType == StartEndBlockType.NeverOnOwnLine))
{
// delete the end block string
endPoint.StartOfLine();
SkipColumns(endPoint, bdata.mIndentation);
if (GetTextOnLine(endPoint, bdata.mMatchedBlockEnd.Length) == bdata.mMatchedBlockEnd)
{
// delete the whole line
endPoint.EndOfLine();
EnvDTE.EditPoint secondLastLinePoint = endPoint.CreateEditPoint();
secondLastLinePoint.LineUp(1);
secondLastLinePoint.EndOfLine();
secondLastLinePoint.Delete(endPoint);
}
else
{
// delete just the string
EnvDTE.EditPoint eolPoint = endPoint.CreateEditPoint();
eolPoint.EndOfLine();
int endOffset = endPoint.GetText(eolPoint).LastIndexOf(bdata.mMatchedBlockEnd);
endPoint.CharRight(endOffset);
endPoint.Delete(eolPoint);
}
}
else if (block.mBlockEndType == StartEndBlockType.AlwaysOnOwnLine)
{
// just move up al line as there is nothing interesting on it
endPoint.LineUp(1);
}
endPoint.EndOfLine();
// now loop down the lines
while (!isLastLine)
{
if (curPoint.Line >= endPoint.Line)
{
isLastLine = true;
}
curPoint.StartOfLine();
if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.AlwaysOnOwnLine))
{
curPoint.LineDown(1);// simply go to the next line
continue;
}
else if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.NeverOnOwnLine))
{
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart);
}
else if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne))
{
// we will automatically pull up the next line if we can. We
// also haqndle the case where traling spaces from the block
// start have been removed
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart);
if ((!AtLineEndIgnoringWhiteSpace(curPoint)) || isLastLine)
{
isStartOnSeparateLine = false;
}
else if (LineJustContainsContinuation(curPoint.Line + 1, bdata.mIndentation, block.mLineStart, pset, pt))
{
isStartOnSeparateLine = true;
}
else
{
isStartOnSeparateLine = false;
if (bdata.mSpacesTrimmedOffBlockStart > 0)
{
curPoint.Insert(new String(' ', bdata.mSpacesTrimmedOffBlockStart));
// change these as we reprocess line!
bdata.mMatchedBlockStart += new String(' ', bdata.mSpacesTrimmedOffBlockStart);
bdata.mSpacesTrimmedOffBlockStart = 0;
}
EnvDTE.EditPoint nextLineStartPoint = curPoint.CreateEditPoint();
nextLineStartPoint.LineDown(1);
nextLineStartPoint.StartOfLine();
SkipColumns(nextLineStartPoint, bdata.mIndentation);
SkipString(nextLineStartPoint, block.mLineStart);
curPoint.Delete(nextLineStartPoint);
continue;// reprocess the line as it now may be last
}
}
else // just a regular line start
{
// pass over line start
SkipColumns(curPoint, bdata.mIndentation);
if (GetTextOnLine(curPoint, block.mLineStart.Length) != block.mLineStart)
{
if ((block.mBlockEndType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
(GetTextOnLine(curPoint, bdata.mMatchedBlockEnd.Length) == bdata.mMatchedBlockEnd))
{
break;// we are done!
}
else if (GetTextOnLine(curPoint, block.mLineStart.TrimEnd().Length) == block.mLineStart.TrimEnd())
{
curPoint.LineDown(1);
continue; // empty line with just trimmed block line
// start
}
else
{
throw new System.ArgumentException("Error parsing block line start");
}
}
curPoint.CharRight(block.mLineStart.Length);
}
// ASSERT: past the comment block start or comment line start
// for the line
int lastStartPre = GetRestOfLine(curPoint).ToLower().LastIndexOf("<pre>");
int lastEndPre = GetRestOfLine(curPoint).ToLower().LastIndexOf("</pre>");
// work out if we are in a preformatted block
if ((lastStartPre != -1) && (lastStartPre > lastEndPre))
{
isInPreformmatedBlock = true;
}
// check all cases that stop wrapping of this line to the next
if (isInPreformmatedBlock ||
AtLineEndIgnoringWhiteSpace(curPoint) ||
pset.matchesBreakFlowString(GetRestOfLine(curPoint), false))
{
if ((lastEndPre != -1) && (lastEndPre > lastStartPre))
{
isInPreformmatedBlock = false;
}
curPoint.LineDown(1);
continue;
}
bool breakLine = pset.matchesBreakFlowString(GetRestOfLine(curPoint), true);
// work out if we are in a preformatted block
if ((lastEndPre != -1) && (lastEndPre > lastStartPre))
{
isInPreformmatedBlock = false;
}
// work out indent for current line
int currentIndent = -1;
int thisIndent;
if (pset.matchesBulletPoint(GetRestOfLine(curPoint), out thisIndent, out currentIndent))
{
// We need to convert current indent to number of columns
// as at the moment it is number of characters.
EnvDTE.EditPoint tempPoint = curPoint.CreateEditPoint();
tempPoint.CharRight(currentIndent);
currentIndent = tempPoint.DisplayColumn - curPoint.DisplayColumn;
// Now advance on this line by the size of the bullet point.
curPoint.CharRight(thisIndent);
}
else
{
currentIndent = SkipWhitespace(curPoint);
}
if ((block.mBlockStartType == StartEndBlockType.NeverOnOwnLine) &&
(curPoint.Line == bdata.mStartLine))
{
// Need to account that on the first line the block start
// may have a different length to the line start.
//
// Note the reason we do not do the multi/ single option here
// is that if we are pulling up text onto the first line we
// actually break the reflowing indentation rule. This all
// needs to be thought through a bit better.
currentIndent += bdata.mMatchedBlockStart.Length - block.mLineStart.Length;
}
int blockWrapWidth = pset.mWrapWidth;
if ((bdata.mIndentation + block.mLineStart.Length + currentIndent + pset.mMinimumBlockWidth) > blockWrapWidth)
{
blockWrapWidth = bdata.mIndentation + block.mLineStart.Length + currentIndent + pset.mMinimumBlockWidth;
}
// Now see if we can wrap into the next line, or if we wrap by
// inserting a new line before it.
EnvDTE.EditPoint nextLinePoint = null;
bool wrapIntoNextLine = false;
if (!isLastLine && !breakLine)
{
nextLinePoint = curPoint.CreateEditPoint();
nextLinePoint.LineDown(1);
nextLinePoint.StartOfLine();
SkipColumns(nextLinePoint, bdata.mIndentation);
if ((block.mLineStart.TrimEnd().Length != block.mLineStart.Length) &&
(GetRestOfLine(nextLinePoint).CompareTo(block.mLineStart.TrimEnd()) == 0))
{
// handle the next line that is completely empty with
// rimmed line end
nextLinePoint = null;
}
else
{
SkipString(nextLinePoint, block.mLineStart);
if (!pset.matchesBulletPoint(GetRestOfLine(nextLinePoint)) &&
!pset.matchesBreakFlowString(GetRestOfLine(nextLinePoint), false) &&
(SkipWhitespace(nextLinePoint) == currentIndent))
{
wrapIntoNextLine = true;
}
else
{
nextLinePoint = null;
}
}
}
// if on the first line and we can'd wrap the text into the next
// line, then push any text on the first line down to a separate
// line
if ((block.mBlockStartType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
(curPoint.Line == bdata.mStartLine) &&
!wrapIntoNextLine &&
!isLastLine &&
!isStartOnSeparateLine)
{
isStartOnSeparateLine = true;
curPoint.StartOfLine();
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart.TrimEnd());
curPoint.Delete(bdata.mMatchedBlockStart.Length - bdata.mMatchedBlockStart.TrimEnd().Length);
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
continue;
}
// ASSERT: if we have got here, there is at least one word on
// this line, and if wrapIntoNextLine then there is at least one
// word on the next line
// now go to the start of the first word that passes the wrap
// point, or the end of the line if it is sooner
int wordCount = 0;
while (((curPoint.DisplayColumn - 1) <= blockWrapWidth) &&
!AtLineEndIgnoringWhiteSpace(curPoint))
{
wordCount++;
GoToEndOfNextWord(curPoint);
}
if ((curPoint.DisplayColumn - 1) <= blockWrapWidth)
{
// the end of line occurs at or before the wrap point. Try
// to fill in the gap from the next line if we can
if (!wrapIntoNextLine)
{
curPoint.LineDown(1);
}
else
{
int charsToFill = blockWrapWidth - ((curPoint.DisplayColumn - 1) + 1);//+1 for extra space
EnvDTE.EditPoint nextLineEndPoint = nextLinePoint.CreateEditPoint();
int numChars = 0;
int numWords = 0;
while ((numChars < charsToFill) &&
!AtLineEndIgnoringWhiteSpace(nextLineEndPoint))
{
numWords++;
GoToEndOfNextWord(nextLineEndPoint);
numChars = nextLineEndPoint.DisplayColumn - nextLinePoint.DisplayColumn;
}
if ((numChars > charsToFill) && (numWords > 1))
{
GoToEndOfPreviousWord(nextLineEndPoint);
numChars = nextLineEndPoint.DisplayColumn - nextLinePoint.DisplayColumn;
}
if ((numChars <= 0) || (numChars > charsToFill))
{
// the first word on the next line is too long to
// pull up
// push comment block start onto separate line and
// retry if we can
if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
!isStartOnSeparateLine)
{
isStartOnSeparateLine = true;
curPoint.StartOfLine();
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart.TrimEnd());
curPoint.Delete(bdata.mMatchedBlockStart.Length - bdata.mMatchedBlockStart.TrimEnd().Length);
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
}
else
{
// just skip onto the next line
curPoint.LineDown(1);
}
}
else
{
// delete trailing whitespace from this line
EnvDTE.EditPoint lineEndPoint = curPoint.CreateEditPoint();
lineEndPoint.EndOfLine();
curPoint.Delete(lineEndPoint);
// get new string from next line and insert it
string st = nextLinePoint.GetText(nextLineEndPoint);
if (AtLineEndIgnoringWhiteSpace(nextLineEndPoint))
{
// no text left on next line, so delete the
// whole thing
nextLineEndPoint.EndOfLine();
curPoint.Delete(nextLineEndPoint);
curPoint.Insert(" " + st);
// don't move curPoint down as we want to
// reprocess this line in case there is more
// room left
}
else
{
// there is still text left on the next line
// push comment block start onto separate line
// if neccesary
if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
!isStartOnSeparateLine)
{
isStartOnSeparateLine = true;
curPoint.StartOfLine();
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart.TrimEnd());
curPoint.Delete(bdata.mMatchedBlockStart.Length - bdata.mMatchedBlockStart.TrimEnd().Length);
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
// reprocess this moved down line!
}
else
{
// remove trailing string as well as
// trailing spaces
while ((nextLineEndPoint.GetText(1) == " ") ||
(nextLineEndPoint.GetText(1) == "\t"))
{
nextLineEndPoint.CharRight(1);
}
nextLinePoint.Delete(nextLineEndPoint);
curPoint.Insert(" " + st);
curPoint.LineDown(1);//move to next line
}
}
}
}
}
else // ((curPoint.DisplayColumn-1) > blockWrapWidth)
{
// push start onto separate line if neccesary
if ((curPoint.Line == bdata.mStartLine) &&
(block.mBlockStartType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
!isStartOnSeparateLine)
{
isStartOnSeparateLine = true;
curPoint.StartOfLine();
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, bdata.mMatchedBlockStart.TrimEnd());
curPoint.Delete(bdata.mMatchedBlockStart.Length - bdata.mMatchedBlockStart.TrimEnd().Length);
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
isLastLine = false; // forces reprocess even if isLatLine
// was just true
continue; // reprocess the just moved line
}
// this line overflows the word wrap. Move back to the end
// of the last word that doesn't overflow if possible
if (wordCount > 1)
{
GoToEndOfPreviousWord(curPoint);
}
if (AtLineEndIgnoringWhiteSpace(curPoint))
{
curPoint.LineDown(1); // the single line is too long, so
// forget about it
// and go to the next line
}
else
{
// copy the remainder of the line after a space but
// delete the space as well
if (!wrapIntoNextLine)
{
EnvDTE.EditPoint dataStartPoint = curPoint.CreateEditPoint();
SkipWhitespace(dataStartPoint);
curPoint.Delete(dataStartPoint);
// insert a whole new line
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
if (currentIndent > 0)
{
curPoint.Insert(GetIndentationString(curPoint.DisplayColumn, currentIndent, blockTabSize));
}
}
else
{
// insert at the start of the next line
EnvDTE.EditPoint dataStartPoint = curPoint.CreateEditPoint();
SkipWhitespace(dataStartPoint);
EnvDTE.EditPoint lineEndPoint = curPoint.CreateEditPoint();
lineEndPoint.EndOfLine();
string st = dataStartPoint.GetText(lineEndPoint).TrimEnd();
curPoint.Delete(lineEndPoint);
nextLinePoint.Insert(st + " ");
curPoint.LineDown(1);
}
// if there is enough there to create one or multiple
// lines, then create them
while (true)
{
curPoint.StartOfLine();
SkipColumns(curPoint, bdata.mIndentation);
SkipString(curPoint, block.mLineStart);
SkipColumns(curPoint, currentIndent);
int myWordCount = 0;
while ((curPoint.DisplayColumn - 1) <= blockWrapWidth &&
!AtLineEndIgnoringWhiteSpace(curPoint))
{
myWordCount++;
GoToEndOfNextWord(curPoint);
}
if ((curPoint.DisplayColumn - 1) <= blockWrapWidth)
{
break; // don't move down a line as we want to
// reprocess this line
}
if (myWordCount > 1)
{
GoToEndOfPreviousWord(curPoint);
}
if (AtLineEndIgnoringWhiteSpace(curPoint))
{
break;
}
EnvDTE.EditPoint dataStartPoint = curPoint.CreateEditPoint();
SkipWhitespace(dataStartPoint);
curPoint.Delete(dataStartPoint);
curPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + block.mLineStart);
if (currentIndent > 0)
{
curPoint.Insert(GetIndentationString(curPoint.DisplayColumn, currentIndent, blockTabSize));
}
// process the just created line in the next
// iteration
}
}
}
}
if ((block.mBlockEndType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) &&
(endPoint.Line != bdata.mStartLine))
{
endPoint.EndOfLine();
endPoint.Insert(eol + GetIndentationString(1, bdata.mIndentation, blockTabSize) + bdata.mMatchedBlockEnd);
}
else if ((block.mBlockEndType == StartEndBlockType.OnOwnLineIfBlockIsMoreThanOne) ||
(block.mBlockEndType == StartEndBlockType.NeverOnOwnLine))
{
endPoint.EndOfLine();
endPoint.Insert(bdata.mMatchedBlockEnd);
}
}