// Token: 0x0600349E RID: 13470 RVA: 0x000EA1A0 File Offset: 0x000E83A0
internal MarkerList GetLastMarkerStyles(MarkerList mlHave, MarkerList mlWant)
{
MarkerList markerList = new MarkerList();
if (mlHave.Count > 0 || mlWant.Count == 0)
{
return(markerList);
}
bool flag = true;
for (int i = this.Count - 1; i >= 0; i--)
{
DocumentNode documentNode = this.EntryAt(i);
if (documentNode.Type == DocumentNodeType.dnCell || documentNode.Type == DocumentNodeType.dnTable)
{
break;
}
if (documentNode.Type == DocumentNodeType.dnListItem)
{
DocumentNode parentOfType = documentNode.GetParentOfType(DocumentNodeType.dnCell);
if (parentOfType != null && !parentOfType.IsPending)
{
break;
}
DocumentNode parentOfType2 = documentNode.GetParentOfType(DocumentNodeType.dnShape);
if (parentOfType2 == null || parentOfType2.IsPending)
{
for (DocumentNode parent = documentNode.Parent; parent != null; parent = parent.Parent)
{
if (parent.Type == DocumentNodeType.dnList)
{
MarkerListEntry markerListEntry = new MarkerListEntry();
markerListEntry.Marker = parent.FormatState.Marker;
markerListEntry.StartIndexOverride = parent.FormatState.StartIndex;
markerListEntry.StartIndexDefault = parent.FormatState.StartIndexDefault;
markerListEntry.VirtualListLevel = parent.VirtualListLevel;
markerListEntry.ILS = parent.FormatState.ILS;
markerList.Insert(0, markerListEntry);
if (markerListEntry.Marker != MarkerStyle.MarkerBullet)
{
flag = false;
}
}
}
break;
}
}
}
if (markerList.Count == 1 && flag)
{
markerList.RemoveRange(0, 1);
}
return(markerList);
}
internal MarkerList GetLastMarkerStyles(MarkerList mlHave, MarkerList mlWant)
{
MarkerList ml = new MarkerList();
if (mlHave.Count > 0 || mlWant.Count == 0)
{
return ml;
}
bool bAllBullet = true;
for (int i = Count - 1; i >= 0; i--)
{
DocumentNode dn = EntryAt(i);
// Don't reopen a list across a table.
if (dn.Type == DocumentNodeType.dnCell || dn.Type == DocumentNodeType.dnTable)
{
break;
}
if (dn.Type == DocumentNodeType.dnListItem)
{
// Don't open a list item in a closed table.
DocumentNode dnCell = dn.GetParentOfType(DocumentNodeType.dnCell);
if (dnCell != null && !dnCell.IsPending)
{
break;
}
// Ignore list items in shapes - note the continue since these didn't effect list continuation.
DocumentNode dnShape = dn.GetParentOfType(DocumentNodeType.dnShape);
if (dnShape != null && !dnShape.IsPending)
{
continue;
}
// OK, gather up the list structure that I'm potentially reopening.
for (DocumentNode dnList = dn.Parent; dnList != null; dnList = dnList.Parent)
{
// Note that I'm building this list up in the reverse order of GetOpenMarkerStyles
if (dnList.Type == DocumentNodeType.dnList)
{
MarkerListEntry mle = new MarkerListEntry();
mle.Marker = dnList.FormatState.Marker;
mle.StartIndexOverride = dnList.FormatState.StartIndex;
mle.StartIndexDefault = dnList.FormatState.StartIndexDefault;
mle.VirtualListLevel = dnList.VirtualListLevel;
mle.ILS = dnList.FormatState.ILS;
ml.Insert(0, mle);
if (mle.Marker != MarkerStyle.MarkerBullet)
{
bAllBullet = false;
}
}
}
break;
}
}
// If all bullets at one level, don't do the continuation thing for simpler content generation.
if (ml.Count == 1 && bAllBullet)
{
ml.RemoveRange(0, 1);
}
return ml;
}
private void EnsureListAndListItem(FormatState formatState, DocumentNodeArray dna, MarkerList mlHave, MarkerList mlWant, int nMatch)
{
int nInsertAt;
bool added = false;
int nLists = mlHave.Count;
int nLevel = mlWant.Count;
// Close any open lists that don't match the ones we want.
bool bInField = dna.FindUnmatched(DocumentNodeType.dnFieldBegin) >= 0;
if (nLists > nMatch)
{
DocumentNode documentNodePara = dna.Pop();
while (nLists > nMatch)
{
int nOpen = dna.FindPending(DocumentNodeType.dnList);
if (nOpen >= 0)
{
dna.CloseAt(nOpen);
// Only coalesce if this is a top-level list. Otherwise I want to get
// the full structure to use for margin fixups so I delay coalescing.
// No, don't coalesce since a later list may need to get merged with this one.
// if (!bInField && dna.FindPending(DocumentNodeType.dnList) < 0)
// dna.CoalesceChildren(_converterState, nOpen);
}
nLists--;
mlHave.RemoveRange(mlHave.Count - 1, 1);
}
dna.Push(documentNodePara);
}
if (nLists < nLevel)
{
// Multiple immediately nested lists are handled poorly in Avalon and are usually an indication
// of bad input from Word (or some other word processor). Clip the number of lists we'll create here.
if (nLevel != nLists + 1)
{
// I'm going to truncate, but make the list I create here of the specific type at this level.
if (nLevel <= mlWant.Count)
{
mlWant[nLists] = mlWant[mlWant.Count - 1];
}
nLevel = nLists + 1;
}
// Ensure sufficient lists are open - this may be our first indication
// Insert the list nodes right before the current paragraph
nInsertAt = dna.Count - 1;
while (nLists < nLevel)
{
added = true;
DocumentNode dnList = new DocumentNode(DocumentNodeType.dnList);
DocumentNode dnLI = new DocumentNode(DocumentNodeType.dnListItem);
dna.InsertNode(nInsertAt, dnLI);
dna.InsertNode(nInsertAt, dnList);
// Set the list properties
MarkerListEntry mle = mlWant.EntryAt(nLists);
dnList.FormatState.Marker = mle.Marker;
dnList.FormatState.StartIndex = mle.StartIndexToUse;
dnList.FormatState.StartIndexDefault = mle.StartIndexDefault;
dnList.VirtualListLevel = mle.VirtualListLevel;
dnList.FormatState.ILS = mle.ILS;
nLists++;
}
}
// Ensure listitem is open
nInsertAt = dna.Count - 1;
int nList = dna.FindPending(DocumentNodeType.dnList);
if (nList >= 0)
{
int nLI = dna.FindPending(DocumentNodeType.dnListItem, nList);
if (nLI >= 0 && !added && !formatState.IsContinue)
{
DocumentNode documentNodePara = dna.Pop();
dna.CloseAt(nLI);
// Don't coalesce - I may need to do margin fixup.
// dna.CoalesceChildren(_converterState, nLI);
dna.Push(documentNodePara);
nLI = -1;
nInsertAt = dna.Count - 1;
}
if (nLI == -1)
{
DocumentNode dnLI = new DocumentNode(DocumentNodeType.dnListItem);
dna.InsertNode(nInsertAt, dnLI);
}
}
}
