protected static int GetWrappedLineTrimmedLength(BufferLine line, BufferLine nextLine, int cols)
{
// If this is the last row in the wrapped line, get the actual trimmed length
if (nextLine == null)
{
return(line.GetTrimmedLength());
}
// Detect whether the following line starts with a wide character and the end of the current line
// is null, if so then we can be pretty sure the null character should be excluded from the line
// length]
bool endsInNull = !(line.HasContent(cols - 1)) && line.GetWidth(cols - 1) == 1;
bool followingLineStartsWithWide = nextLine.GetWidth(0) == 2;
if (endsInNull && followingLineStartsWithWide)
{
return(cols - 1);
}
return(cols);
}
public override void Reflow(int newCols, int newRows, int oldCols, int oldRows)
{
// Gather all BufferLines that need to be inserted into the Buffer here so that they can be
// batched up and only committed once
List <InsertionSet> toInsert = new List <InsertionSet> ();
int countToInsert = 0;
// Go backwards as many lines may be trimmed and this will avoid considering them
for (int y = Buffer.Lines.Length - 1; y >= 0; y--)
{
// Check whether this line is a problem or not, if not skip it
BufferLine nextLine = Buffer.Lines [y];
int lineLength = nextLine.GetTrimmedLength();
if (!nextLine.IsWrapped && lineLength <= newCols)
{
continue;
}
// Gather wrapped lines and adjust y to be the starting line
List <BufferLine> wrappedLines = new List <BufferLine> ();
wrappedLines.Add(nextLine);
while (nextLine.IsWrapped && y > 0)
{
nextLine = Buffer.Lines [--y];
wrappedLines.Insert(0, nextLine);
}
// If these lines contain the cursor don't touch them, the program will handle fixing up
// wrapped lines with the cursor
int absoluteY = Buffer.YBase + Buffer.Y;
if (absoluteY >= y && absoluteY < y + wrappedLines.Count)
{
continue;
}
int lastLineLength = wrappedLines [wrappedLines.Count - 1].GetTrimmedLength();
int [] destLineLengths = GetNewLineLengths(wrappedLines, oldCols, newCols);
int linesToAdd = destLineLengths.Length - wrappedLines.Count;
int trimmedLines;
if (Buffer.YBase == 0 && Buffer.Y != Buffer.Lines.Length - 1)
{
// If the top section of the buffer is not yet filled
trimmedLines = Math.Max(0, Buffer.Y - Buffer.Lines.MaxLength + linesToAdd);
}
else
{
trimmedLines = Math.Max(0, Buffer.Lines.Length - Buffer.Lines.MaxLength + linesToAdd);
}
// Add the new lines
List <BufferLine> newLines = new List <BufferLine> ();
for (int i = 0; i < linesToAdd; i++)
{
BufferLine newLine = Buffer.GetBlankLine(CharData.DefaultAttr, true);
newLines.Add(newLine);
}
if (newLines.Count > 0)
{
toInsert.Add(new InsertionSet {
Start = y + wrappedLines.Count + countToInsert,
Lines = newLines.ToArray()
});
countToInsert += newLines.Count;
}
newLines.ForEach(l => wrappedLines.Add(l));
// Copy buffer data to new locations, this needs to happen backwards to do in-place
int destLineIndex = destLineLengths.Length - 1; // Math.floor(cellsNeeded / newCols);
int destCol = destLineLengths [destLineIndex]; // cellsNeeded % newCols;
if (destCol == 0)
{
destLineIndex--;
destCol = destLineLengths [destLineIndex];
}
int srcLineIndex = wrappedLines.Count - linesToAdd - 1;
int srcCol = lastLineLength;
while (srcLineIndex >= 0)
{
int cellsToCopy = Math.Min(srcCol, destCol);
wrappedLines [destLineIndex].CopyCellsFrom(wrappedLines [srcLineIndex], srcCol - cellsToCopy, destCol - cellsToCopy, cellsToCopy);
destCol -= cellsToCopy;
if (destCol == 0)
{
destLineIndex--;
if (destLineIndex >= 0)
{
destCol = destLineLengths [destLineIndex];
}
}
srcCol -= cellsToCopy;
if (srcCol == 0)
{
srcLineIndex--;
int wrappedLinesIndex = Math.Max(srcLineIndex, 0);
srcCol = GetWrappedLineTrimmedLength(wrappedLines, wrappedLinesIndex, oldCols);
}
}
// Null out the end of the line ends if a wide character wrapped to the following line
for (int i = 0; i < wrappedLines.Count; i++)
{
if (destLineLengths [i] < newCols)
{
wrappedLines [i] [destLineLengths [i]] = CharData.Null;
}
}
// Adjust viewport as needed
int viewportAdjustments = linesToAdd - trimmedLines;
while (viewportAdjustments-- > 0)
{
if (Buffer.YBase == 0)
{
if (Buffer.Y < newRows - 1)
{
Buffer.Y++;
Buffer.Lines.Pop();
}
else
{
Buffer.YBase++;
Buffer.YDisp++;
}
}
else
{
// Ensure ybase does not exceed its maximum value
if (Buffer.YBase < Math.Min(Buffer.Lines.MaxLength, Buffer.Lines.Length + countToInsert) - newRows)
{
if (Buffer.YBase == Buffer.YDisp)
{
Buffer.YDisp++;
}
Buffer.YBase++;
}
}
}
Buffer.SavedY = Math.Min(Buffer.SavedY + linesToAdd, Buffer.YBase + newRows - 1);
}
Rearrange(toInsert, countToInsert);
}
