/// <summary>
/// Gets the line layout for a given line.
/// </summary>
/// <param name="lineIndex">The line.</param>
/// <param name="lineContexts"></param>
/// <returns></returns>
public override Layout GetLineLayout(
int lineIndex,
LineContexts lineContexts)
{
// Make sure we're on the proper thread.
CheckGuiThread();
// If we have a context, never cache it.
if (lineContexts != LineContexts.None)
{
return(base.GetLineLayout(lineIndex, lineContexts));
}
// We need to get a write lock on the entire cache to avoid
// anything else making changes.
Layout layout;
using (new ReadLock(access))
{
CachedLine line = GetCachedLine(lineIndex);
layout = line.Layout;
}
// Process any queued changes.
ProcessQueuedLineChanges();
// Return the resulting layout.
return(layout);
}
/// <summary>
/// Uses the cache to retrieve the heights of the individual lines.
/// </summary>
/// <param name="startLineIndex">The start line.</param>
/// <param name="endLineIndex">The end line.</param>
/// <returns></returns>
public override int GetLineLayoutHeight(
int startLineIndex,
int endLineIndex)
{
// Make sure we're on the proper thread.
CheckGuiThread();
// We need to get a write lock on the entire cache to avoid
// anything else making changes.
int results = 0;
using (new ReadLock(access))
{
// Normalize to our line count.
endLineIndex = Math.Min(endLineIndex, LineBuffer.LineCount - 1);
// Go through the lines and get the count.
for (int index = startLineIndex;
index <= endLineIndex;
index++)
{
CachedLine line = GetCachedLine(index);
results += line.Height;
}
}
// Process any queued changes.
ProcessQueuedLineChanges();
// Return the resulting height of the region.
return(results);
}
/// <summary>
/// Processes the lines inserted. This will never be called inside the
/// access' write lock.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="LineRangeEventArgs"/> instance containing the event data.</param>
private void ProcessLinesInserted(
object sender,
LineRangeEventArgs args)
{
// Make sure we're on the proper thread.
CheckGuiThread();
// Create a short list of new cache items for the line. Since we are
// dealing with indexes, we need to get the count.
int count = args.EndLineIndex - args.StartLineIndex + 1;
var newLines = new CachedLine[count];
for (int index = 0;
index < count;
index++)
{
newLines[index] = new CachedLine();
}
// Insert the lines into the array.
lines.InsertRange(args.StartLineIndex, newLines);
// Call the base implementation to cascade the events up.
base.OnLinesInserted(sender, args);
}
/// <summary>
/// Gets the cached line and ensures it is populated.
/// </summary>
/// <param name="lineIndex">The line.</param>
/// <returns></returns>
private CachedLine GetCachedLine(int lineIndex)
{
if (lineIndex >= lines.Count)
{
return(new CachedLine());
}
// Pull out the cached line.
CachedLine cachedLine = lines[lineIndex];
cachedLine.Cache(EditorViewRenderer, lineIndex);
return(cachedLine);
}
/// <summary>
/// Gets the lines that are visible in the given view area.
/// </summary>
/// <param name="viewArea">The view area.</param>
/// <param name="startLine">The start line.</param>
/// <param name="endLine">The end line.</param>
public override void GetLineLayoutRange(
Rectangle viewArea,
out int startLine,
out int endLine)
{
// Make sure we're on the proper thread.
CheckGuiThread();
// We need to get a write lock on the entire cache to avoid
// anything else making changes.
using (new ReadLock(access))
{
// Start the start and end line to the first one.
startLine = endLine = 0;
// Go through and find the lines that are within range of the
// view port.
int height = 0;
double bottom = viewArea.Y + viewArea.Height;
for (int lineIndex = 0;
lineIndex < lines.Count;
lineIndex++)
{
// Get the line for the current index.
CachedLine line = GetCachedLine(lineIndex);
// If the line is current below the view port, then update
// the two lines.
endLine = lineIndex;
if (height < viewArea.Y)
{
// We are below the line, so update it.
startLine = lineIndex;
}
if (height > bottom)
{
break;
}
// Update the line height.
height += line.Height;
}
}
// Process any queued changes.
ProcessQueuedLineChanges();
}
private bool OnIdleUpdate()
{
// Make sure we're identified as running.
isRunning = true;
// Keep track of when we started. UtcNow requires less CPU overhead
// so we use that instead.
DateTime started = DateTime.UtcNow;
// Loop through the lines in the cache renderer and update each
// one in turn. We restart at the last point we updated to make sure
// we can get through all the lines in the short time we have in
// this loop.
for (; currentIndex < lines.Count;
currentIndex++)
{
// Check to see if we exceeded our time yet.
if ((DateTime.UtcNow - started) > maximumTime)
{
// We have to stop processing now, but we need to keep going.
return(true);
}
// Get the next line and check to see if it isn't cached. If it
// isn't, then we need to cache it but also keep track so we
// go through the lines again.
CachedLine line = lines[currentIndex];
if (!line.IsCached)
{
needRestart = true;
line.Cache(renderer, currentIndex);
}
}
// If we need to restart, then cycle through it again.
if (needRestart)
{
needRestart = false;
currentIndex = 0;
return(true);
}
// If we got this far, we have completely gone through the lines
// without updating any of them. To avoid the overhead of calling
// this repeatedly, we return false and will restart later.
isRunning = false;
return(false);
}
/// <summary>
/// Processes the line changed. This will never be called inside the
/// access' write lock.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The args.</param>
private void ProcessLineChanged(
object sender,
LineChangedArgs args)
{
// Make sure we're on the proper thread.
CheckGuiThread();
// Get the line and reset it.
CachedLine line = lines[args.LineIndex];
line.Reset();
// Call the base implementation to cascade the events up.
base.OnLineChanged(sender, args);
}
private void ClearCacheLines(TextRange selection)
{
LinePosition firstLinePosition = selection.FirstLinePosition;
int firstLineIndex = firstLinePosition.GetLineIndex(
LineBuffer, LinePositionOptions.NoBoundsChecking);
LinePosition lastLinePosition = selection.LastLinePosition;
int lastLineIndex = lastLinePosition.GetLineIndex(
LineBuffer, LinePositionOptions.NoBoundsChecking);
for (int lineIndex = firstLineIndex;
lineIndex <= lastLineIndex;
lineIndex++)
{
CachedLine line = lines[lineIndex];
line.Reset();
}
}
