// Token: 0x06006B2A RID: 27434 RVA: 0x001EF184 File Offset: 0x001ED384
internal void UpdGetChangeInText(out int dcpStart, out int ddcpOld, out int ddcpNew)
{
DtrList dtrList = base.StructuralCache.DtrsFromRange(base.ParagraphStartCharacterPosition, base.LastFormatCch);
if (dtrList != null)
{
dcpStart = dtrList[0].StartIndex - base.ParagraphStartCharacterPosition;
ddcpNew = dtrList[0].PositionsAdded;
ddcpOld = dtrList[0].PositionsRemoved;
if (dtrList.Length > 1)
{
for (int i = 1; i < dtrList.Length; i++)
{
int num = dtrList[i].StartIndex - dtrList[i - 1].StartIndex;
ddcpNew += num + dtrList[i].PositionsAdded;
ddcpOld += num + dtrList[i].PositionsRemoved;
}
}
if (!base.StructuralCache.CurrentFormatContext.FinitePage)
{
this.UpdateEmbeddedObjectsCache <AttachedObject>(ref this._attachedObjects, dcpStart, ddcpOld, ddcpNew - ddcpOld);
this.UpdateEmbeddedObjectsCache <InlineObject>(ref this._inlineObjects, dcpStart, ddcpOld, ddcpNew - ddcpOld);
}
Invariant.Assert(dcpStart >= 0 && base.Cch >= dcpStart && base.LastFormatCch >= dcpStart);
ddcpOld = Math.Min(ddcpOld, base.LastFormatCch - dcpStart + 1);
ddcpNew = Math.Min(ddcpNew, base.Cch - dcpStart + 1);
return;
}
dcpStart = (ddcpOld = (ddcpNew = 0));
}
/// <summary>
/// Add new DirtyTextRange.
/// </summary>
/// <param name="dtr">New DTR being added.</param>
internal void AddDirtyTextRange(DirtyTextRange dtr)
{
if (_dtrs == null)
{
_dtrs = new DtrList();
}
_dtrs.Merge(dtr);
}
/// <summary>
/// Invalidates main text segment for bottomless pages if DTR list for this para is non-null.
/// </summary>
private void InvalidateMainTextSegment()
{
DtrList dtrs = StructuralCache.DtrsFromRange(ParagraphStartCharacterPosition, LastFormatCch);
if (dtrs != null && dtrs.Length > 0)
{
_mainTextSegment.InvalidateStructure(dtrs[0].StartIndex);
}
}
// Token: 0x0600682B RID: 26667 RVA: 0x001D5720 File Offset: 0x001D3920
private void InvalidateMainTextSegment()
{
DtrList dtrList = base.StructuralCache.DtrsFromRange(base.ParagraphStartCharacterPosition, base.LastFormatCch);
if (dtrList != null && dtrList.Length > 0)
{
this._mainTextSegment.InvalidateStructure(dtrList[0].StartIndex);
}
}
// ------------------------------------------------------------------
// Retrieve list of dtrs from range.
//
// dcpNew - Distance from the beginning of TextContainer after all
// tree changes.
// cchOld - Number of characters in the range, but before any
// tree changes.
//
// Returns: List of DRTs for specified range.
// ------------------------------------------------------------------
internal DtrList DtrsFromRange(int dcpNew, int cchOld)
{
DtrList dtrs = null;
int i = 0;
int first, last;
int positionsAdded = 0;
// Find the first dtr intersecting with the specified range.
// Since DTRs store dcp before any changes, during iteration
// accumulate positionsAdded (number of characters added to the tree
// up to the current point).
while (i < _count)
{
if (dcpNew <= _dtrs[i].StartIndex + positionsAdded + _dtrs[i].PositionsAdded)
{
break;
}
positionsAdded += _dtrs[i].PositionsAdded - _dtrs[i].PositionsRemoved;
++i;
}
first = i;
// Find the last dtr intersecting with the specified range.
// dcpNew-positionsAdded points to position before any tree changes, from
// where we start counting cchOld.
// Do not add characters (positionsAdded), since start position has been already found.
while (i < _count)
{
if (dcpNew - positionsAdded + cchOld <= _dtrs[i].StartIndex + _dtrs[i].PositionsRemoved)
{
// If there is no intersection with the current DTR, go to the previous one.
if (dcpNew - positionsAdded + cchOld < _dtrs[i].StartIndex)
{
--i;
}
break;
}
++i;
}
last = (i < _count) ? i : _count - 1;
// If there are DTRs in the specified range, create new DtrList object
if (last >= first)
{
dtrs = new DtrList();
while (last >= first)
{
// Since dcpNew is after tree changes, add positionsAdded to all dtrs
// to build dtr list relative to dcpNew position.
DirtyTextRange dtr = _dtrs[first];
dtr.StartIndex += positionsAdded;
dtrs.Append(dtr);
++first;
}
}
return(dtrs);
}
/// <summary>
/// Invalidate content's structural cache.
/// </summary>
internal void InvalidateStructure()
{
if (_mainTextSegment != null)
{
DtrList dtrs = _structuralCache.DtrList;
if (dtrs != null)
{
_mainTextSegment.InvalidateStructure(dtrs[0].StartIndex);
}
}
}
// Token: 0x06006A4A RID: 27210 RVA: 0x001E40A0 File Offset: 0x001E22A0
internal void InvalidateStructure()
{
if (this._mainTextSegment != null)
{
DtrList dtrList = this._structuralCache.DtrList;
if (dtrList != null)
{
this._mainTextSegment.InvalidateStructure(dtrList[0].StartIndex);
}
}
}
// Token: 0x060067B4 RID: 26548 RVA: 0x001D1260 File Offset: 0x001CF460
internal DtrList DtrsFromRange(int dcpNew, int cchOld)
{
DtrList dtrList = null;
int i = 0;
int num = 0;
while (i < this._count && dcpNew > this._dtrs[i].StartIndex + num + this._dtrs[i].PositionsAdded)
{
num += this._dtrs[i].PositionsAdded - this._dtrs[i].PositionsRemoved;
i++;
}
int num2 = i;
while (i < this._count)
{
if (dcpNew - num + cchOld <= this._dtrs[i].StartIndex + this._dtrs[i].PositionsRemoved)
{
if (dcpNew - num + cchOld < this._dtrs[i].StartIndex)
{
i--;
break;
}
break;
}
else
{
i++;
}
}
int j = (i < this._count) ? i : (this._count - 1);
if (j >= num2)
{
dtrList = new DtrList();
while (j >= num2)
{
DirtyTextRange dtr = this._dtrs[num2];
dtr.StartIndex += num;
dtrList.Append(dtr);
num2++;
}
}
return(dtrList);
}
// Token: 0x060067A6 RID: 26534 RVA: 0x001D0CB8 File Offset: 0x001CEEB8
private UpdateRecord UpdateRecordFromDtr(DtrList dtrs, DirtyTextRange dtr, int dcpContent)
{
UpdateRecord updateRecord = new UpdateRecord();
updateRecord.Dtr = dtr;
BaseParagraph baseParagraph = this._firstChild;
int num = dcpContent;
if (num < updateRecord.Dtr.StartIndex)
{
while (baseParagraph != null && num + baseParagraph.LastFormatCch <= updateRecord.Dtr.StartIndex && (num + baseParagraph.LastFormatCch != updateRecord.Dtr.StartIndex || !(baseParagraph is TextParagraph)))
{
num += baseParagraph.LastFormatCch;
baseParagraph = baseParagraph.Next;
}
}
updateRecord.FirstPara = baseParagraph;
if (baseParagraph == null)
{
updateRecord.ChangeType = PTS.FSKCHANGE.fskchNew;
}
else if (num < updateRecord.Dtr.StartIndex)
{
updateRecord.ChangeType = PTS.FSKCHANGE.fskchInside;
}
else
{
updateRecord.ChangeType = PTS.FSKCHANGE.fskchNew;
}
updateRecord.SyncPara = null;
while (baseParagraph != null)
{
if (num + baseParagraph.LastFormatCch > updateRecord.Dtr.StartIndex + updateRecord.Dtr.PositionsRemoved || (num + baseParagraph.LastFormatCch == updateRecord.Dtr.StartIndex + updateRecord.Dtr.PositionsRemoved && updateRecord.ChangeType != PTS.FSKCHANGE.fskchNew))
{
updateRecord.SyncPara = baseParagraph.Next;
break;
}
num += baseParagraph.LastFormatCch;
baseParagraph = baseParagraph.Next;
}
return(updateRecord);
}
// Token: 0x0600679A RID: 26522 RVA: 0x001CFD2C File Offset: 0x001CDF2C
internal void UpdGetSegmentChange(out PTS.FSKCHANGE fskch)
{
if (base.StructuralCache.CurrentFormatContext.FinitePage)
{
DtrList dtrList = base.StructuralCache.DtrsFromRange(TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.BeforeStart), base.LastFormatCch);
if (dtrList != null)
{
int cpfromElement = TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.AfterStart);
DirtyTextRange dirtyTextRange = dtrList[0];
int num = cpfromElement;
BaseParagraph baseParagraph = this._firstChild;
if (num < dirtyTextRange.StartIndex)
{
while (baseParagraph != null && num + baseParagraph.LastFormatCch <= dirtyTextRange.StartIndex && (num + baseParagraph.LastFormatCch != dirtyTextRange.StartIndex || !(baseParagraph is TextParagraph)))
{
num += baseParagraph.Cch;
baseParagraph = baseParagraph.Next;
}
if (baseParagraph != null)
{
baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchInside, false);
}
}
else
{
baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
}
if (baseParagraph != null)
{
for (baseParagraph = baseParagraph.Next; baseParagraph != null; baseParagraph = baseParagraph.Next)
{
baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
}
}
this._changeType = PTS.FSKCHANGE.fskchInside;
}
}
fskch = this._changeType;
}
// ------------------------------------------------------------------
// Retrieve list of dtrs from range.
//
// dcpNew - Distance from the beginning of TextContainer after all
// tree changes.
// cchOld - Number of characters in the range, but before any
// tree changes.
//
// Returns: List of DRTs for specified range.
// ------------------------------------------------------------------
internal DtrList DtrsFromRange(int dcpNew, int cchOld)
{
DtrList dtrs = null;
int i = 0;
int first, last;
int positionsAdded = 0;
// Find the first dtr intersecting with the specified range.
// Since DTRs store dcp before any changes, during iteration
// accumulate positionsAdded (number of characters added to the tree
// up to the current point).
while (i < _count)
{
if (dcpNew <= _dtrs[i].StartIndex + positionsAdded + _dtrs[i].PositionsAdded)
{
break;
}
positionsAdded += _dtrs[i].PositionsAdded - _dtrs[i].PositionsRemoved;
++i;
}
first = i;
// Find the last dtr intersecting with the specified range.
// dcpNew-positionsAdded points to position before any tree changes, from
// where we start counting cchOld.
// Do not add characters (positionsAdded), since start position has been already found.
while (i < _count)
{
if (dcpNew - positionsAdded + cchOld <= _dtrs[i].StartIndex + _dtrs[i].PositionsRemoved)
{
// If there is no intersection with the current DTR, go to the previous one.
if (dcpNew - positionsAdded + cchOld < _dtrs[i].StartIndex)
{
--i;
}
break;
}
++i;
}
last = (i < _count) ? i : _count-1;
// If there are DTRs in the specified range, create new DtrList object
if (last >= first)
{
dtrs = new DtrList();
while (last >= first)
{
// Since dcpNew is after tree changes, add positionsAdded to all dtrs
// to build dtr list relative to dcpNew position.
DirtyTextRange dtr = _dtrs[first];
dtr.StartIndex += positionsAdded;
dtrs.Append(dtr);
++first;
}
}
return dtrs;
}
// Callback from the TextContainer when a highlight changes.
private void OnHighlightChanged(object sender, HighlightChangedEventArgs args)
{
// The only supported highlight type for TextBoxView is SpellerHighlight.
if (args.OwnerType != typeof(SpellerHighlightLayer))
{
return;
}
if (_dirtyList == null)
{
_dirtyList = new DtrList();
}
//
// Add the change to our dirty list.
//
foreach (TextSegment segment in args.Ranges)
{
int positionsCovered = segment.End.Offset - segment.Start.Offset;
DirtyTextRange dirtyTextRange = new DirtyTextRange(segment.Start.Offset, positionsCovered, positionsCovered);
_dirtyList.Merge(dirtyTextRange);
}
//
// Force a re-measure.
//
// NB: it's not currently possible to InvalidateArrange here.
// "Render only" changes from the highlight layer change the way we
// ultimately feed text to the formatter. Introducing breaks for
// highlights may actually change the layout of the text as
// characters are interpreted in different contexts. Dev10 Bugs
// 511849 has an example.
//
InvalidateMeasure();
}
// Callback from the TextContainer on a document edit.
private void OnTextContainerChange(object sender, TextContainerChangeEventArgs args)
{
if (args.Count == 0)
{
// A no-op for this control. Happens when IMECharCount updates happen
// without corresponding SymbolCount changes.
return;
}
//
// Add the change to our dirty list.
//
if (_dirtyList == null)
{
_dirtyList = new DtrList();
}
DirtyTextRange dirtyTextRange = new DirtyTextRange(args);
_dirtyList.Merge(dirtyTextRange);
//
// Force a re-measure.
//
InvalidateMeasure();
}
// ------------------------------------------------------------------
// Build UpdateRecord from DTR.
// ------------------------------------------------------------------
private UpdateRecord UpdateRecordFromDtr(
DtrList dtrs,
DirtyTextRange dtr,
int dcpContent)
{
UpdateRecord ur = new UpdateRecord();
// (1) Initialize DTR
ur.Dtr = dtr;
// (2) Find first paragraph affected by DTR
BaseParagraph para = _firstChild;
BaseParagraph paraPrev = null;
// There might be gaps between paragraphs (example: content of List element, only
// nested Lists or ListItems are valid paragraphs, all other content is skipped).
// For this reason always use para.ParagraphStartCharacterPosition to get the first
// character position of the current paragraph.
int dcpPara = dcpContent;
if (dcpPara < ur.Dtr.StartIndex)
{
while (para != null)
{
// We're looking for first affected para - We start with dco content. For
// all paras but TextParagraph, StartPosition/EndPosition is
// |<Section></Section>|, so insertion at edge points is adding new paragraphs,
// not affecting current. For textpara, <Paragraph>|abcde|</Paragraph>,
// insertion at edge points is a change inside for that text paragraph.
if (
dcpPara + para.LastFormatCch > ur.Dtr.StartIndex ||
(dcpPara + para.LastFormatCch == ur.Dtr.StartIndex && para is TextParagraph))
{
break; // the first paragraph is found
}
dcpPara += para.LastFormatCch;
paraPrev = para;
para = para.Next;
}
}
// else the change is before the first paragraph
ur.FirstPara = para;
// (3) Determine change type for the fist affected paragraph
if (para == null)
{
ur.ChangeType = PTS.FSKCHANGE.fskchNew;
}
else if (dcpPara < ur.Dtr.StartIndex)
{
ur.ChangeType = PTS.FSKCHANGE.fskchInside;
}
else
{
ur.ChangeType = PTS.FSKCHANGE.fskchNew;
}
// (4) Find synchronization point, the first paragraph after DTR
ur.SyncPara = null;
while (para != null)
{
if ( (dcpPara + para.LastFormatCch > ur.Dtr.StartIndex + ur.Dtr.PositionsRemoved)
|| (dcpPara + para.LastFormatCch == ur.Dtr.StartIndex + ur.Dtr.PositionsRemoved && ur.ChangeType != PTS.FSKCHANGE.fskchNew))
{
ur.SyncPara = para.Next;
break;
}
dcpPara += para.LastFormatCch;
para = para.Next;
}
return ur;
}
/// <summary>
/// Add new DirtyTextRange.
/// </summary>
/// <param name="dtr">New DTR being added.</param>
internal void AddDirtyTextRange(DirtyTextRange dtr)
{
if (_dtrs == null)
{
_dtrs = new DtrList();
}
_dtrs.Merge(dtr);
}
// Token: 0x060067A4 RID: 26532 RVA: 0x001D0AC8 File Offset: 0x001CECC8
private bool NeedsUpdate()
{
DtrList dtrList = base.StructuralCache.DtrsFromRange(base.ParagraphStartCharacterPosition, base.LastFormatCch);
return(dtrList != null);
}
// Token: 0x060067A5 RID: 26533 RVA: 0x001D0AF4 File Offset: 0x001CECF4
private void BuildUpdateRecord()
{
this._ur = null;
DtrList dtrList = base.StructuralCache.DtrsFromRange(base.ParagraphStartCharacterPosition, base.LastFormatCch);
UpdateRecord updateRecord2;
if (dtrList != null)
{
UpdateRecord updateRecord = null;
for (int i = 0; i < dtrList.Length; i++)
{
int cpfromElement = TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.AfterStart);
updateRecord2 = this.UpdateRecordFromDtr(dtrList, dtrList[i], cpfromElement);
if (updateRecord == null)
{
this._ur = updateRecord2;
}
else
{
updateRecord.Next = updateRecord2;
}
updateRecord = updateRecord2;
}
updateRecord2 = this._ur;
while (updateRecord2.Next != null)
{
if (updateRecord2.SyncPara != null)
{
if (updateRecord2.SyncPara.Previous == updateRecord2.Next.FirstPara)
{
updateRecord2.MergeWithNext();
}
else if (updateRecord2.SyncPara == updateRecord2.Next.FirstPara && updateRecord2.Next.ChangeType == PTS.FSKCHANGE.fskchNew)
{
updateRecord2.MergeWithNext();
}
else
{
updateRecord2 = updateRecord2.Next;
}
}
else
{
updateRecord2.MergeWithNext();
}
}
}
updateRecord2 = this._ur;
while (updateRecord2 != null && updateRecord2.FirstPara != null)
{
BaseParagraph baseParagraph;
if (updateRecord2.ChangeType == PTS.FSKCHANGE.fskchInside)
{
baseParagraph = updateRecord2.FirstPara.Next;
updateRecord2.FirstPara.Next = null;
}
else
{
baseParagraph = updateRecord2.FirstPara;
}
while (baseParagraph != updateRecord2.SyncPara)
{
if (baseParagraph.Next != null)
{
baseParagraph.Next.Previous = null;
}
if (baseParagraph.Previous != null)
{
baseParagraph.Previous.Next = null;
}
baseParagraph.Dispose();
baseParagraph = baseParagraph.Next;
}
updateRecord2 = updateRecord2.Next;
}
if (this._ur != null && this._ur.FirstPara == this._firstChild && this._ur.ChangeType == PTS.FSKCHANGE.fskchNew)
{
this._firstChild = null;
}
this._firstParaValidInUpdateMode = true;
}