internal override PageItemHelper WritePaginationInfo()
{
PageItemHelper pageItemHelper = new PageItemHelper(8);
base.WritePaginationInfoProperties(pageItemHelper);
return(pageItemHelper);
}
internal override void UpdateItem(PageItemHelper itemHelper)
{
if (itemHelper != null)
{
base.UpdateItem(itemHelper);
m_prevPageEnd = itemHelper.PrevPageEnd;
}
}
internal void UpdateItem(ReportSectionHelper sectionHelper)
{
if (sectionHelper != null)
{
m_sectionIndex = sectionHelper.SectionIndex;
m_bodyHelper = sectionHelper.BodyHelper;
}
}
internal override PageItemHelper WritePaginationInfo()
{
PageItemHelper pageItemHelper = new PageItemHelper(4);
base.WritePaginationInfoProperties(pageItemHelper);
pageItemHelper.BodyIndex = m_bodyIndex;
pageItemHelper.PrevPageEnd = m_prevPageEnd;
if (m_childrenBody != null && m_childrenBody[m_bodyIndex] != null)
{
pageItemHelper.ChildPage = m_childrenBody[m_bodyIndex].WritePaginationInfo();
}
return(pageItemHelper);
}
internal void Reset()
{
m_header = null;
m_footer = null;
m_rplReportSection = null;
m_bodyOffset = 0L;
m_offset = 0L;
m_itemRenderSizes = null;
m_sectionIndex = -1;
m_bodyHelper = null;
m_itemsOnPage = 0;
if (Done)
{
m_body = null;
}
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
m_itemPageSizes.AdjustHeightTo(0.0);
m_itemPageSizes.AdjustWidthTo(0.0);
m_itemState = State.OnPage;
interactivity?.RegisterItem(this, pageContext);
if (rplWriter != null && m_itemRenderSizes == null)
{
CreateItemRenderSizes(null, pageContext, createForRepeat: false);
}
return(true);
}
private static void ReadPageItemProperties(PageItemHelper item, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(item != null, "The item helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
byte b = reader.ReadByte();
while (b != byte.MaxValue && reader.BaseStream.Position <= offsetEndPage)
{
item.ProcessPageItemToken(b, reader, offsetEndPage);
b = reader.ReadByte();
}
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
}
private static void ReadReportSectionProperties(ReportSectionHelper section, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(section != null, "The section helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
if (reader.ReadByte() == 23)
{
section.SectionIndex = reader.ReadInt32();
section.BodyHelper = PageItemHelper.ReadItems(reader, offsetEndPage);
reader.ReadByte();
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
return;
}
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
private static void ReadSubReportProperties(PageItemHelper item, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(item != null, "The item helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
byte b = reader.ReadByte();
while (b != byte.MaxValue && reader.BaseStream.Position <= offsetEndPage)
{
switch (b)
{
case 23:
item.BodyIndex = reader.ReadInt32();
break;
case 11:
item.PrevPageEnd = reader.ReadDouble();
break;
case 19:
{
byte b2 = reader.ReadByte();
if (b2 != 7)
{
throw new InvalidDataException(SPBRes.InvalidTokenPaginationItems(b2.ToString("x", CultureInfo.InvariantCulture)));
}
PageItemContainerHelper pageItemContainerHelper = new PageItemContainerHelper(b2);
ReadPageItemContainerProperties(pageItemContainerHelper, reader, offsetEndPage);
item.ChildPage = pageItemContainerHelper;
break;
}
default:
item.ProcessPageItemToken(b, reader, offsetEndPage);
break;
}
b = reader.ReadByte();
}
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
}
private void CreateChildren(PageContext pageContext, PageItemHelper lastPageInfo, bool needsFirstBodyUpdate)
{
Microsoft.ReportingServices.OnDemandReportRendering.SubReport subReport = (Microsoft.ReportingServices.OnDemandReportRendering.SubReport)m_source;
ReportSectionCollection reportSections = subReport.Report.ReportSections;
if (m_childrenBody == null)
{
m_childrenBody = new PageItem[reportSections.Count];
for (int i = m_bodyIndex; i < reportSections.Count; i++)
{
m_childrenBody[i] = new ReportBody(subReport.Report.ReportSections[i].Body, subReport.Report.ReportSections[i].Width, pageContext);
}
}
if (needsFirstBodyUpdate)
{
m_childrenBody[m_bodyIndex].UpdateItem(lastPageInfo.ChildPage);
UpdateItemPageState(subReport.OmitBorderOnPageBreak);
}
}
internal void UpdateItem(PageItemHelper itemHelper, RPLWriter rplWriter, PageContext pageContext)
{
if (itemHelper != null)
{
PageItemRepeatWithHelper pageItemRepeatWithHelper = itemHelper as PageItemRepeatWithHelper;
RSTrace.RenderingTracer.Assert(pageItemRepeatWithHelper != null, "This should be a RepeatWith");
m_relativeTop = pageItemRepeatWithHelper.RelativeTop;
m_relativeBottom = pageItemRepeatWithHelper.RelativeBottom;
m_relativeTopToBottom = pageItemRepeatWithHelper.RelativeTopToBottom;
m_dataRegionIndex = pageItemRepeatWithHelper.DataRegionIndex;
if (pageItemRepeatWithHelper.RenderItemSize != null)
{
m_renderItemSize = pageItemRepeatWithHelper.RenderItemSize.GetNewItem();
}
if (m_pageItem != null)
{
PageContext pageContext2 = new PageContext(pageContext, PageContext.PageContextFlags.FullOnPage, PageContext.IgnorePBReasonFlag.Repeated);
m_pageItem.CalculateRepeatWithPage(rplWriter, pageContext2, null);
}
}
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
ItemSizes contentSize = null;
bool flag = ResolveItemHiddenState(rplWriter, interactivity, pageContext, createForRepeat: false, ref contentSize);
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Bottom);
if (!pageContext.IgnorePageBreaks)
{
if (base.PageBreakAtEnd)
{
m_itemState = State.OnPagePBEnd;
pageContext.RegisterPageBreak(new PageBreakInfo(PageBreak, base.ItemName));
}
if (!flag)
{
pageContext.RegisterPageName(PageName);
}
}
if (pageContext.TracingEnabled && pageContext.IgnorePageBreaks)
{
TracePageBreakAtEndIgnored(pageContext);
}
if (rplWriter != null)
{
if (m_itemRenderSizes == null)
{
CreateItemRenderSizes(contentSize, pageContext, createForRepeat: false);
}
if (!flag)
{
WriteItemToStream(rplWriter, pageContext);
}
}
return(true);
}
private void CalculateIndexOfFirstBodyOnPage(PageItemHelper lastPageInfo, out bool firstPage, out bool needsFirstBodyUpdate)
{
firstPage = false;
needsFirstBodyUpdate = false;
if (lastPageInfo != null)
{
m_bodyIndex = lastPageInfo.BodyIndex;
if (lastPageInfo.ChildPage != null)
{
needsFirstBodyUpdate = true;
return;
}
if (m_bodyIndex < 0)
{
firstPage = true;
}
m_bodyIndex++;
}
else
{
m_bodyIndex = 0;
firstPage = true;
}
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
ItemSizes contentSize = null;
bool flag = ResolveItemHiddenState(rplWriter, interactivity, pageContext, createForRepeat: false, ref contentSize);
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Bottom);
if (rplWriter != null)
{
if (m_itemRenderSizes == null)
{
CreateItemRenderSizes(contentSize, pageContext, createForRepeat: false);
}
if (!flag)
{
WriteItemToStream(rplWriter, pageContext);
}
}
return(true);
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
return(true);
}
private static void ReadTablixProperties(PageTablixHelper item, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(item != null, "The item helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
byte b = reader.ReadByte();
while (b != byte.MaxValue && reader.BaseStream.Position <= offsetEndPage)
{
switch (b)
{
case 16:
item.LevelForRepeat = reader.ReadInt32();
break;
case 22:
item.IgnoreTotalsOnLastLevel = reader.ReadBoolean();
break;
case 17:
item.TablixCreateState = ReadIntList(reader, offsetEndPage);
break;
case 18:
item.MembersInstanceIndex = ReadIntList(reader, offsetEndPage);
break;
case 19:
{
byte b2 = reader.ReadByte();
PageItemHelper pageItemHelper = null;
switch (b2)
{
case 5:
case 6:
ReadPageItemContainerProperties((PageItemContainerHelper)(pageItemHelper = new PageItemContainerHelper(b2)), reader, offsetEndPage);
break;
case 1:
case 2:
case 3:
case 8:
case 9:
case 10:
case 12:
case 15:
case 17:
pageItemHelper = new PageItemHelper(b2);
ReadPageItemProperties(pageItemHelper, reader, offsetEndPage);
break;
case 4:
pageItemHelper = new PageItemHelper(b2);
ReadSubReportProperties(pageItemHelper, reader, offsetEndPage);
break;
case 11:
ReadTablixProperties((PageTablixHelper)(pageItemHelper = new PageTablixHelper(b2)), reader, offsetEndPage);
break;
default:
throw new InvalidDataException(SPBRes.InvalidTokenPaginationItems(b2.ToString("x", CultureInfo.InvariantCulture)));
}
item.ChildPage = pageItemHelper;
break;
}
default:
item.ProcessPageItemToken(b, reader, offsetEndPage);
break;
}
b = reader.ReadByte();
}
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
}
private static void ReadPageItemContainerProperties(PageItemContainerHelper item, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(item != null, "The item helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
byte b = reader.ReadByte();
while (b != byte.MaxValue && reader.BaseStream.Position <= offsetEndPage)
{
switch (b)
{
case 6:
item.ItemsCreated = reader.ReadBoolean();
break;
case 11:
item.PrevPageEnd = reader.ReadDouble();
break;
case 9:
{
if (reader.ReadByte() != 3)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
PageItemHelper pageItemHelper = new PageItemHelper(3);
ReadPageItemProperties(pageItemHelper, reader, offsetEndPage);
item.RightEdgeItem = pageItemHelper;
break;
}
case 7:
{
int num3 = reader.ReadInt32();
int[] array3 = new int[num3];
for (int k = 0; k < num3; k++)
{
array3[k] = reader.ReadInt32();
}
item.IndexesLeftToRight = array3;
break;
}
case 20:
{
int num4 = reader.ReadInt32();
int[] array4 = new int[num4];
for (int l = 0; l < num4; l++)
{
array4[l] = reader.ReadInt32();
}
item.IndexesTopToBottom = array4;
break;
}
case 10:
{
int num2 = reader.ReadInt32();
PageItemHelper[] array2 = new PageItemHelper[num2];
for (int j = 0; j < num2; j++)
{
byte b3 = reader.ReadByte();
switch (b3)
{
case 5:
case 6:
ReadPageItemContainerProperties((PageItemContainerHelper)(array2[j] = new PageItemContainerHelper(b3)), reader, offsetEndPage);
break;
case 1:
case 2:
case 3:
case 8:
case 9:
case 10:
case 12:
case 15:
case 17:
array2[j] = new PageItemHelper(b3);
ReadPageItemProperties(array2[j], reader, offsetEndPage);
break;
case 4:
array2[j] = new PageItemHelper(b3);
ReadSubReportProperties(array2[j], reader, offsetEndPage);
break;
case 11:
ReadTablixProperties((PageTablixHelper)(array2[j] = new PageTablixHelper(b3)), reader, offsetEndPage);
break;
case 14:
reader.ReadByte();
array2[j] = null;
break;
default:
throw new InvalidDataException(SPBRes.InvalidTokenPaginationItems(b3.ToString("x", CultureInfo.InvariantCulture)));
}
}
item.Children = array2;
break;
}
case 8:
{
int num = reader.ReadInt32();
PageItemRepeatWithHelper[] array = new PageItemRepeatWithHelper[num];
for (int i = 0; i < num; i++)
{
byte b2 = reader.ReadByte();
array[i] = new PageItemRepeatWithHelper(b2);
if (b2 != 14)
{
ReadRepeatWithItemProperties(array[i], reader, offsetEndPage);
continue;
}
reader.ReadByte();
array[i] = null;
}
item.RepeatWithItems = array;
break;
}
default:
item.ProcessPageItemToken(b, reader, offsetEndPage);
break;
}
b = reader.ReadByte();
}
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
}
internal void NextPage(RPLWriter rplWriter, ref ReportSectionHelper lastPageInfo, int page, int totalPages, Interactivity interactivity, bool hasPaginationChunk)
{
ReportSection reportSection = null;
bool flag = true;
bool flag2 = false;
bool flag3 = false;
bool flag4 = (m_sections.Count <= 1) ? true : false;
PageItemHelper lastBodyInfo = null;
int pageNumber = page;
int totalPages2 = totalPages;
int sectionStartIndex = -1;
CreateFirstSectionBodyFromPaginationState(page, lastPageInfo, ref lastBodyInfo, ref sectionStartIndex);
if (m_pageContext.ImageConsolidation != null)
{
m_pageContext.ImageConsolidation.Reset();
m_pageContext.ImageConsolidation.SetName(m_report.Name, page);
}
m_pageContext.PageNumber = page;
m_pageContext.PageTotalInfo.RegisterPageNumberForStart(page);
m_pageContext.PageTotalInfo.RetrievePageBreakData(page, out pageNumber, out totalPages2);
WriteStartItemToStream(rplWriter);
WriteReportPageLayoutAtStart(rplWriter);
for (int i = sectionStartIndex; i < m_sections.Count; i++)
{
ReportSection reportSection2 = m_sections[i];
bool delayedHeader = false;
bool delayedFooter = false;
bool lastSectionOnPage = false;
if (flag)
{
reportSection = reportSection2;
}
if (i == m_sections.Count - 1)
{
flag4 = true;
}
if (reportSection2.Body == null)
{
reportSection2.SetContext();
}
reportSection2.CalculatePage(rplWriter, page, totalPages, pageNumber, totalPages2, flag, flag4, interactivity, m_pageContext.PageHeight, ref lastBodyInfo, ref delayedHeader, ref delayedFooter, ref lastSectionOnPage);
if (m_pageContext.CancelPage)
{
ResetSectionsOnPage(sectionStartIndex, i);
return;
}
if (flag)
{
flag = false;
flag2 = delayedHeader;
lastPageInfo = null;
}
if (delayedFooter)
{
flag3 = delayedFooter;
}
m_sectionSizes.Add(reportSection2.ItemRenderSizes);
m_sectionOffsets.Add(reportSection2.Offset);
if (m_pageContext.PageHeight != double.MaxValue)
{
m_pageContext.PageHeight -= reportSection2.Body.ItemPageSizes.Height;
}
if (lastSectionOnPage)
{
if (i > m_lastSectionIndex)
{
m_lastSectionIndex = i;
}
reportSection2.SectionIndex = i;
break;
}
}
if (m_pageContext.TracingEnabled)
{
if (Done)
{
TracePageBreakIgnoredAtBottom(page, m_pageContext.Common.PageBreakInfo);
}
else if (m_pageContext.Common.PageBreakInfo != null)
{
TraceLogicalPageBreak(page + 1, m_pageContext.Common.PageBreakInfo);
}
else
{
TraceVerticalPageBreak(page + 1);
}
}
m_pageContext.ApplyPageBreak(page);
int num = 1;
double bodyWidth = 0.0;
double bodyHeight = 0.0;
bool flag5 = flag4 && m_sections[m_lastSectionIndex].Done;
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
WriteEndReportBodyToRPLStream2008(rplWriter, sectionStartIndex, ref bodyWidth, ref bodyHeight);
if (rplWriter != null || (interactivity != null && !interactivity.Done && interactivity.NeedPageHeaderFooter))
{
WriteReportPageLayout2008(rplWriter, bodyWidth, bodyHeight);
if (flag3)
{
m_sections[m_lastSectionIndex].CalculateDelayedFooter(rplWriter, interactivity);
num++;
}
if (flag2 && (page == 1 || !flag5 || reportSection.IsHeaderPrintOnLastPage()))
{
reportSection.CalculateDelayedHeader(rplWriter, interactivity);
num++;
}
if (rplWriter != null && rplWriter.BinaryWriter != null)
{
rplWriter.BinaryWriter.Write(byte.MaxValue);
}
}
}
else if (flag2)
{
if (!flag5)
{
CalculateDelayedHeader(rplWriter, reportSection, interactivity);
}
else
{
reportSection.WriteEndItemToStream(rplWriter);
if (rplWriter != null)
{
m_sectionSizes[0].Height = reportSection.ItemRenderSizes.Height;
m_sectionSizes[0].Width = reportSection.ItemRenderSizes.Width;
m_sectionOffsets[0] = reportSection.Offset;
}
}
}
interactivity?.RegisterDocMapRootLabel(m_report.Instance.UniqueName, m_pageContext);
if (m_pageContext.ImageConsolidation != null)
{
m_pageContext.ImageConsolidation.RenderToStream();
}
string pageName = m_pageContext.PageTotalInfo.GetPageName(page);
WriteEndItemToStream(rplWriter, sectionStartIndex, num, reportSection.Header, m_sections[m_lastSectionIndex].Footer, bodyWidth, bodyHeight, pageName);
m_pageContext.PageHeight = m_pageContext.OriginalPageHeight;
if (hasPaginationChunk)
{
ReleaseResourcesOnPage(rplWriter, sectionStartIndex, includeLastSection: false);
}
else
{
ReleaseResourcesOnPage(rplWriter, sectionStartIndex, includeLastSection: true);
}
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
WriteStartItemToStream(rplWriter, pageContext);
PageItemHelper[] array = null;
if (m_itemsCreated)
{
PageItemContainerHelper pageItemContainerHelper = lastPageInfo as PageItemContainerHelper;
RSTrace.RenderingTracer.Assert(pageItemContainerHelper != null || lastPageInfo == null, "This should be a container");
CreateChildrenFromPaginationState(m_source.ReportItemCollection, pageContext, pageItemContainerHelper, isSimple: false);
ResolveRepeatWithFromPaginationState(pageItemContainerHelper, rplWriter, pageContext);
UpdateItemPageState(pageContext, omitBorderOnPageBreak: false);
if (pageItemContainerHelper != null)
{
array = pageItemContainerHelper.Children;
}
}
else
{
CreateChildren(m_source.ReportItemCollection, pageContext, m_itemPageSizes.Width, m_itemPageSizes.Height);
ResolveRepeatWith(m_source.ReportItemCollection, pageContext);
m_itemsCreated = true;
}
double num = parentTopInPage + m_itemPageSizes.Top;
double pageItemHeight = 0.0;
int num2 = 0;
PageItem[] childrenOnPage = null;
bool flag = true;
bool flag2 = true;
ProcessPageBreaks processPageBreaks = null;
List <int> repeatedSiblings = null;
double num3 = 0.0;
if (m_children != null)
{
double num4 = m_itemPageSizes.PaddingBottom;
PageItem pageItem = null;
processPageBreaks = new ProcessPageBreaks();
for (int i = 0; i < m_children.Length; i++)
{
pageItem = m_children[i];
if (pageItem == null)
{
continue;
}
num3 = pageItem.ReserveSpaceForRepeatWith(m_repeatWithItems, pageContext);
if (array != null)
{
pageItem.CalculatePage(rplWriter, array[i], pageContext, m_children, m_repeatWithItems, num + num3, ref pageItemHeight, interactivity);
}
else
{
pageItem.CalculatePage(rplWriter, null, pageContext, m_children, m_repeatWithItems, num + num3, ref pageItemHeight, interactivity);
}
if (!pageContext.FullOnPage)
{
processPageBreaks.ProcessItemPageBreaks(pageItem);
if (pageItem.ItemState != State.OnPage && pageItem.ItemState != State.OnPageHidden)
{
if (pageItem.ItemState != State.OnPagePBEnd)
{
flag = false;
}
if (pageItem.ItemState != State.Below)
{
flag2 = false;
}
}
else
{
m_prevPageEnd = pageItemHeight;
flag2 = false;
}
if (rplWriter != null)
{
pageItem.MergeRepeatSiblings(ref repeatedSiblings);
}
}
num4 = Math.Max(num4, pageItem.ItemPageSizes.Bottom + m_itemPageSizes.PaddingBottom);
}
ConsumeWhitespaceVertical(m_itemPageSizes, num4, pageContext);
}
if (pageContext.CancelPage)
{
m_itemState = State.Below;
m_children = null;
m_rplElement = null;
return(false);
}
bool flag3 = false;
if (processPageBreaks != null && processPageBreaks.HasPageBreaks(ref m_prevPageEnd, ref pageItemHeight))
{
if (flag)
{
if (pageItemHeight - m_itemPageSizes.Height != 0.0)
{
flag = false;
}
else
{
flag3 = true;
}
}
}
else if (!pageContext.FullOnPage)
{
if (flag)
{
double num5 = num + m_itemPageSizes.Height;
if ((RoundedDouble)num5 > pageContext.PageHeight && (RoundedDouble)(num5 - m_itemPageSizes.PaddingBottom) <= pageContext.PageHeight)
{
double val = pageContext.PageHeight - num;
m_prevPageEnd = Math.Max(pageItemHeight, val);
pageItemHeight = m_prevPageEnd;
flag = false;
}
else
{
pageItemHeight = m_itemPageSizes.Height;
}
}
else if (flag2 && (RoundedDouble)(num + m_itemPageSizes.Height) > pageContext.PageHeight)
{
m_prevPageEnd = pageContext.PageHeight - num;
pageItemHeight = m_prevPageEnd;
}
}
else
{
pageItemHeight = m_itemPageSizes.Height;
}
if (pageContext.FullOnPage || flag)
{
m_itemState = State.OnPage;
if (flag && flag3)
{
m_itemState = State.OnPagePBEnd;
}
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Top + pageItemHeight);
if (rplWriter != null)
{
CreateItemRenderSizes(null, pageContext, createForRepeat: false);
num2 = CalculateRenderSizes(rplWriter, pageContext, interactivity, repeatedSiblings, out childrenOnPage);
WriteEndItemToStream(rplWriter, num2, childrenOnPage);
}
m_indexesLeftToRight = null;
m_children = null;
}
else
{
m_itemState = State.SpanPages;
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Top + pageItemHeight);
if (rplWriter != null)
{
CreateItemRenderSizes(null, pageContext, createForRepeat: false);
m_itemRenderSizes.PaddingBottom = 0.0;
m_itemRenderSizes.AdjustHeightTo(pageItemHeight);
num2 = CalculateRenderSizes(rplWriter, pageContext, interactivity, repeatedSiblings, out childrenOnPage);
WriteEndItemToStream(rplWriter, num2, childrenOnPage);
}
else
{
ReleaseChildrenOnPage();
}
}
return(true);
}
private void CreateFirstSectionBodyFromPaginationState(int page, ReportSectionHelper lastPageInfo, ref PageItemHelper lastBodyInfo, ref int sectionStartIndex)
{
if (lastPageInfo != null)
{
sectionStartIndex = lastPageInfo.SectionIndex;
m_sections[sectionStartIndex].UpdateItem(lastPageInfo);
if (lastPageInfo.BodyHelper != null)
{
lastBodyInfo = lastPageInfo.BodyHelper;
}
else
{
sectionStartIndex++;
}
return;
}
if (page == 1)
{
sectionStartIndex = 0;
m_sections[sectionStartIndex].Reset();
return;
}
RSTrace.RenderingTracer.Assert(m_lastSectionIndex >= 0 && m_lastSectionIndex < m_sections.Count, "The index of the last section on the previous paginated page should be a valid index");
if (m_sections[m_lastSectionIndex].Done && m_lastSectionIndex < m_sections.Count - 1)
{
m_sections[m_lastSectionIndex].Reset();
sectionStartIndex = m_lastSectionIndex + 1;
}
else
{
sectionStartIndex = m_lastSectionIndex;
m_sections[sectionStartIndex].Reset();
}
}
internal bool CalculatePage(RPLWriter rplWriter, int page, int totalPages, int regionPageNumber, int regionTotalPages, bool firstSectionOnPage, bool lastSection, Interactivity interactivity, double heightToBeUsed, ref PageItemHelper lastBodyInfo, ref bool delayedHeader, ref bool delayedFooter, ref bool lastSectionOnPage)
{
m_pageContext.EvaluatePageHeaderFooter = false;
PageSection pageHeader = m_reportSectionDef.Page.PageHeader;
PageSection pageFooter = m_reportSectionDef.Page.PageFooter;
bool renderHeader = false;
bool renderFooter = false;
if (pageHeader != null || pageFooter != null)
{
m_reportSectionDef.SetPage(regionPageNumber, regionTotalPages, page, totalPages);
}
if ((rplWriter != null || (interactivity != null && !interactivity.Done && interactivity.NeedPageHeaderFooter)) && m_reportSectionDef.NeedsReportItemsOnPage)
{
InitialCheckForHeader(pageHeader, page, totalPages, firstSectionOnPage, ref renderHeader);
InitialCheckForFooter(pageFooter, page, totalPages, lastSection, ref renderFooter);
if (renderHeader || renderFooter)
{
m_pageContext.EvaluatePageHeaderFooter = true;
}
}
WriteStartItemToStream(rplWriter);
double parentHeight = 0.0;
m_body.UpdateItem(lastBodyInfo);
m_body.CalculatePage(rplWriter, lastBodyInfo, m_pageContext, null, null, 0.0, ref parentHeight, interactivity);
m_pageContext.ApplyPageName(page);
m_itemsOnPage++;
if (m_pageContext.CancelPage)
{
m_body = null;
return(false);
}
WriteBodyColumnsToStream(rplWriter);
CreateReportSectionSizes(rplWriter);
CheckForLastSectionOnPage(heightToBeUsed, lastSection, ref lastSectionOnPage);
if (rplWriter != null || (interactivity != null && !interactivity.Done && interactivity.NeedPageHeaderFooter))
{
if (!m_reportSectionDef.NeedsReportItemsOnPage)
{
InitialCheckForHeader(pageHeader, page, totalPages, firstSectionOnPage, ref renderHeader);
InitialCheckForFooter(pageFooter, page, totalPages, lastSection, ref renderFooter);
}
FinalCheckForHeader(pageHeader, page, lastSection && Done, firstSectionOnPage, ref renderHeader);
FinalCheckForFooter(pageFooter, page, lastSection && Done, lastSectionOnPage, ref renderFooter);
if (pageHeader != null || pageFooter != null)
{
string pageName = m_pageContext.PageTotalInfo.GetPageName(page);
m_reportSectionDef.SetPageName(pageName);
m_reportSectionDef.GetPageSections();
}
PageContext pageContext = new PageContext(m_pageContext, PageContext.PageContextFlags.FullOnPage, PageContext.IgnorePBReasonFlag.HeaderFooter);
if (renderFooter)
{
if ((m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation) & lastSectionOnPage)
{
delayedFooter = true;
}
if (!delayedFooter)
{
pageContext.RPLSectionArea = PageContext.RPLReportSectionArea.Footer;
m_footer = new PageHeadFoot(pageFooter, m_reportSectionDef.Width, pageContext);
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
m_footer.CalculateItem(rplWriter, pageContext, isHeader: false, interactivity, native: false);
}
else
{
m_footer.CalculateItem(rplWriter, pageContext, isHeader: false, interactivity, native: true);
}
m_itemsOnPage++;
}
if (m_pageContext.CancelPage)
{
m_body = null;
m_footer = null;
return(false);
}
}
if (renderHeader)
{
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
if (firstSectionOnPage)
{
delayedHeader = true;
}
}
else if (page > 1 && firstSectionOnPage && !pageHeader.PrintOnLastPage && !m_pageContext.AddFirstPageHeaderFooter)
{
delayedHeader = true;
}
if (!delayedHeader)
{
pageContext.RPLSectionArea = PageContext.RPLReportSectionArea.Header;
m_header = new PageHeadFoot(pageHeader, m_reportSectionDef.Width, pageContext);
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
m_header.CalculateItem(rplWriter, pageContext, isHeader: true, interactivity, native: false);
}
else
{
m_header.CalculateItem(rplWriter, pageContext, isHeader: true, interactivity, native: true);
}
m_itemsOnPage++;
}
if (m_pageContext.CancelPage)
{
m_body = null;
m_footer = null;
m_header = null;
return(false);
}
}
}
if (!delayedHeader || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
UpdateReportSectionSizes(rplWriter);
WriteEndItemToStream(rplWriter);
}
lastBodyInfo = null;
return(true);
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
ItemSizes contentSize = null;
if (!m_itemsCreated && ResolveItemHiddenState(rplWriter, interactivity, pageContext, createForRepeat: false, ref contentSize))
{
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Bottom);
if (rplWriter != null)
{
CalculateHiddenItemRenderSize(pageContext, createForRepeat: false);
}
return(true);
}
Microsoft.ReportingServices.OnDemandReportRendering.Rectangle rectangle = (Microsoft.ReportingServices.OnDemandReportRendering.Rectangle)m_source;
PageItemHelper[] array = null;
bool flag = false;
WriteStartItemToStream(rplWriter, pageContext);
bool overrideChild = !pageContext.IsPageBreakRegistered;
if (m_itemsCreated)
{
PageItemContainerHelper pageItemContainerHelper = lastPageInfo as PageItemContainerHelper;
RSTrace.RenderingTracer.Assert(pageItemContainerHelper != null || lastPageInfo == null, "This should be a container");
m_staticItem = CreateChildrenFromPaginationState(rectangle.ReportItemCollection, pageContext, pageItemContainerHelper, rectangle.IsSimple);
ResolveRepeatWithFromPaginationState(pageItemContainerHelper, rplWriter, pageContext);
UpdateItemPageState(pageContext, rectangle.OmitBorderOnPageBreak);
if (pageItemContainerHelper != null)
{
array = pageItemContainerHelper.Children;
}
}
else
{
flag = true;
if (!pageContext.IgnorePageBreaks)
{
pageContext.RegisterPageName(PageName);
}
m_staticItem = CreateChildren(rectangle.ReportItemCollection, pageContext, rectangle.Width.ToMillimeters(), rectangle.Height.ToMillimeters(), rectangle.IsSimple);
ResolveRepeatWith(rectangle.ReportItemCollection, pageContext);
m_itemsCreated = true;
contentSize?.SetPaddings(m_itemPageSizes.PaddingRight, m_itemPageSizes.PaddingBottom);
}
PageContext pageContext2 = pageContext;
if (!pageContext2.FullOnPage)
{
if (base.IgnorePageBreaks)
{
pageContext2 = new PageContext(pageContext, PageContext.PageContextFlags.FullOnPage, PageContext.IgnorePBReasonFlag.Toggled);
}
else if (flag && rectangle.KeepTogether && !pageContext2.KeepTogether)
{
pageContext2 = new PageContext(pageContext);
pageContext2.KeepTogether = true;
if (pageContext.TracingEnabled && parentTopInPage + m_itemPageSizes.Height >= pageContext2.OriginalPageHeight)
{
TracePageGrownOnKeepTogetherItem(pageContext.PageNumber);
}
}
}
double num = parentTopInPage + m_itemPageSizes.Top;
double pageItemHeight = 0.0;
int num2 = 0;
PageItem[] childrenOnPage = null;
bool flag2 = true;
bool flag3 = true;
ProcessPageBreaks processPageBreaks = null;
List <int> repeatedSiblings = null;
double num3 = 0.0;
if (m_children != null)
{
double num4 = m_itemPageSizes.PaddingBottom;
PageItem pageItem = null;
processPageBreaks = new ProcessPageBreaks();
for (int i = 0; i < m_children.Length; i++)
{
pageItem = m_children[i];
if (pageItem == null)
{
continue;
}
num3 = pageItem.ReserveSpaceForRepeatWith(m_repeatWithItems, pageContext2);
if (array != null)
{
pageItem.CalculatePage(rplWriter, array[i], pageContext2, m_children, m_repeatWithItems, num + num3, ref pageItemHeight, interactivity);
}
else
{
pageItem.CalculatePage(rplWriter, null, pageContext2, m_children, m_repeatWithItems, num + num3, ref pageItemHeight, interactivity);
}
if (!pageContext2.FullOnPage)
{
processPageBreaks.ProcessItemPageBreaks(pageItem);
if (pageItem.ItemState != State.OnPage && pageItem.ItemState != State.OnPageHidden)
{
if (pageItem.ItemState != State.OnPagePBEnd)
{
flag2 = false;
}
if (pageItem.ItemState != State.Below)
{
flag3 = false;
}
}
else
{
m_prevPageEnd = pageItemHeight;
flag3 = false;
}
if (rplWriter != null)
{
pageItem.MergeRepeatSiblings(ref repeatedSiblings);
}
}
else if (!pageContext.FullOnPage && rplWriter != null)
{
pageItem.MergeRepeatSiblings(ref repeatedSiblings);
}
num4 = Math.Max(num4, pageItem.ItemPageSizes.Bottom + m_itemPageSizes.PaddingBottom);
}
if (contentSize != null)
{
ConsumeWhitespaceVertical(contentSize, num4, pageContext2);
}
else
{
ConsumeWhitespaceVertical(m_itemPageSizes, num4, pageContext2);
}
}
if (pageContext2.CancelPage)
{
m_itemState = State.Below;
m_children = null;
m_rplElement = null;
return(false);
}
bool flag4 = false;
if (processPageBreaks != null && processPageBreaks.HasPageBreaks(ref m_prevPageEnd, ref pageItemHeight))
{
if (flag2)
{
if (pageItemHeight - m_itemPageSizes.Height != 0.0)
{
flag2 = false;
}
else
{
flag4 = true;
}
}
}
else if (!pageContext2.FullOnPage)
{
if (flag2)
{
double num5 = num + m_itemPageSizes.Height;
if ((RoundedDouble)num5 > pageContext2.PageHeight && (RoundedDouble)(num5 - m_itemPageSizes.PaddingBottom) <= pageContext2.PageHeight)
{
double val = pageContext2.PageHeight - num;
m_prevPageEnd = Math.Max(pageItemHeight, val);
pageItemHeight = m_prevPageEnd;
flag2 = false;
}
else
{
pageItemHeight = m_itemPageSizes.Height;
}
}
else if (flag3 && (RoundedDouble)(num + m_itemPageSizes.Height) > pageContext2.PageHeight)
{
m_prevPageEnd = pageContext2.PageHeight - num;
pageItemHeight = m_prevPageEnd;
}
}
else
{
pageItemHeight = m_itemPageSizes.Height;
}
if (pageContext2.FullOnPage || flag2)
{
m_itemState = State.OnPage;
if (flag2)
{
if (!pageContext2.IgnorePageBreaks && base.PageBreakAtEnd)
{
pageContext.RegisterPageBreak(new PageBreakInfo(PageBreak, base.ItemName), overrideChild);
m_itemState = State.OnPagePBEnd;
}
else if (flag4)
{
m_itemState = State.OnPagePBEnd;
}
if (pageContext2.TracingEnabled && pageContext2.IgnorePageBreaks)
{
TracePageBreakAtEndIgnored(pageContext2);
}
}
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Top + pageItemHeight);
if (rplWriter != null)
{
CreateItemRenderSizes(contentSize, pageContext2, createForRepeat: false);
num2 = CalculateRenderSizes(rplWriter, pageContext2, interactivity, repeatedSiblings, out childrenOnPage);
WriteEndItemToStream(rplWriter, num2, childrenOnPage);
}
m_indexesLeftToRight = null;
m_children = null;
}
else
{
m_itemState = State.SpanPages;
if (rectangle.OmitBorderOnPageBreak)
{
m_rplItemState |= 2;
}
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Top + pageItemHeight);
if (rplWriter != null)
{
CreateItemRenderSizes(null, pageContext2, createForRepeat: false);
m_itemRenderSizes.PaddingBottom = 0.0;
m_itemRenderSizes.AdjustHeightTo(pageItemHeight);
num2 = CalculateRenderSizes(rplWriter, pageContext2, interactivity, repeatedSiblings, out childrenOnPage);
WriteEndItemToStream(rplWriter, num2, childrenOnPage);
}
else
{
ReleaseChildrenOnPage();
}
}
return(true);
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
AdjustOriginFromItemsAbove(siblings, repeatWithItems);
if (!HitsCurrentPage(pageContext, parentTopInPage))
{
return(false);
}
bool firstPage = false;
bool needsFirstBodyUpdate = false;
CalculateIndexOfFirstBodyOnPage(lastPageInfo, out firstPage, out needsFirstBodyUpdate);
ItemSizes contentSize = null;
if (firstPage && ResolveItemHiddenState(rplWriter, interactivity, pageContext, createForRepeat: false, ref contentSize))
{
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Bottom);
if (rplWriter != null && m_itemRenderSizes == null)
{
CreateItemRenderSizes(null, pageContext, createForRepeat: false);
}
return(true);
}
WriteStartItemToStream(rplWriter, pageContext);
CreateChildren(pageContext, lastPageInfo, needsFirstBodyUpdate);
Microsoft.ReportingServices.OnDemandReportRendering.SubReport subReport = (Microsoft.ReportingServices.OnDemandReportRendering.SubReport)m_source;
PageContext pageContext2 = pageContext;
if (!pageContext2.FullOnPage)
{
if (base.IgnorePageBreaks)
{
pageContext2 = new PageContext(pageContext, PageContext.PageContextFlags.FullOnPage, PageContext.IgnorePBReasonFlag.Toggled);
}
else if (firstPage && subReport.KeepTogether && !pageContext2.KeepTogether)
{
pageContext2 = new PageContext(pageContext);
pageContext2.KeepTogether = true;
}
}
m_bodiesOnPage = 0;
double num = parentTopInPage + m_itemPageSizes.Top;
double num2 = 0.0;
double num3 = 0.0;
double num4 = 0.0;
bool flag = false;
for (int i = m_bodyIndex; i < m_childrenBody.Length; i++)
{
if (flag)
{
break;
}
PageItem pageItem = m_childrenBody[i];
double parentHeight = 0.0;
if (needsFirstBodyUpdate)
{
pageItem.CalculatePage(rplWriter, lastPageInfo.ChildPage, pageContext2, null, null, num, ref parentHeight, interactivity);
needsFirstBodyUpdate = false;
}
else
{
pageItem.CalculatePage(rplWriter, null, pageContext2, null, null, num, ref parentHeight, interactivity);
}
if (pageContext2.CancelPage)
{
m_itemState = State.Below;
m_rplElement = null;
m_childrenBody = null;
return(false);
}
if (pageItem.ItemState == State.TopNextPage && i == 0)
{
m_itemState = State.TopNextPage;
m_bodyIndex = -1;
return(false);
}
m_bodiesOnPage++;
num += parentHeight;
num2 += parentHeight;
m_itemState = State.OnPage;
if (!pageContext2.FullOnPage)
{
m_prevPageEnd = num2;
if (pageItem.ItemState != State.OnPage)
{
if (pageItem.ItemState == State.OnPagePBEnd && i == m_childrenBody.Length - 1)
{
m_itemState = State.OnPagePBEnd;
}
else
{
if (pageItem.ItemState == State.Below)
{
m_bodiesOnPage--;
}
m_itemState = State.SpanPages;
m_prevPageEnd = 0.0;
}
}
if (m_itemState == State.SpanPages || m_itemState == State.OnPagePBEnd)
{
flag = true;
}
else if ((RoundedDouble)num >= pageContext2.PageHeight)
{
flag = true;
if (m_itemState == State.OnPage && i < m_childrenBody.Length - 1)
{
m_itemState = State.SpanPages;
}
}
}
if (rplWriter != null)
{
num3 = Math.Max(num3, pageItem.ItemRenderSizes.Width);
num4 += pageItem.ItemRenderSizes.Height;
}
}
if (contentSize == null)
{
m_itemPageSizes.AdjustHeightTo(m_childrenBody[m_bodyIndex + m_bodiesOnPage - 1].ItemPageSizes.Bottom);
}
else
{
contentSize.AdjustHeightTo(m_childrenBody[m_bodyIndex + m_bodiesOnPage - 1].ItemPageSizes.Bottom);
}
if (rplWriter != null)
{
CreateItemRenderSizes(contentSize, pageContext2, createForRepeat: false);
m_itemRenderSizes.AdjustWidthTo(num3);
m_itemRenderSizes.AdjustHeightTo(num4);
WriteEndItemToStream(rplWriter, pageContext2);
}
if (m_itemState != State.SpanPages)
{
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Bottom);
}
else
{
if (subReport.OmitBorderOnPageBreak)
{
m_rplItemState |= 2;
}
parentPageHeight = Math.Max(parentPageHeight, m_itemPageSizes.Top + num2);
}
ReleaseBodyChildrenOnPage();
m_bodyIndex += m_bodiesOnPage - 1;
return(true);
}
private static void ReadRepeatWithItemProperties(PageItemRepeatWithHelper item, BinaryReader reader, long offsetEndPage)
{
RSTrace.RenderingTracer.Assert(item != null, "The item helper is null.");
RSTrace.RenderingTracer.Assert(reader != null, "The pagination stream is null.");
RSTrace.RenderingTracer.Assert(offsetEndPage > 0, "The pagination stream is corrupt.");
byte b = reader.ReadByte();
while (b != byte.MaxValue && reader.BaseStream.Position <= offsetEndPage)
{
switch (b)
{
case 12:
item.RelativeTop = reader.ReadDouble();
break;
case 13:
item.RelativeBottom = reader.ReadDouble();
break;
case 14:
item.RelativeTopToBottom = reader.ReadDouble();
break;
case 15:
item.DataRegionIndex = reader.ReadInt32();
break;
case 1:
item.RenderItemSize = new ItemSizes();
if (item.RenderItemSize.ReadPaginationInfo(reader, offsetEndPage) != 0)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
break;
case 2:
item.RenderItemSize = new PaddItemSizes();
if (item.RenderItemSize.ReadPaginationInfo(reader, offsetEndPage) != 0)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
break;
case 19:
{
byte b2 = reader.ReadByte();
PageItemHelper pageItemHelper = null;
switch (b2)
{
case 5:
case 6:
ReadPageItemContainerProperties((PageItemContainerHelper)(pageItemHelper = new PageItemContainerHelper(b2)), reader, offsetEndPage);
break;
case 1:
case 8:
case 9:
case 12:
pageItemHelper = new PageItemHelper(b2);
ReadPageItemProperties(pageItemHelper, reader, offsetEndPage);
break;
default:
throw new InvalidDataException(SPBRes.InvalidTokenPaginationItems(b2.ToString("x", CultureInfo.InvariantCulture)));
}
item.ChildPage = pageItemHelper;
break;
}
default:
throw new InvalidDataException(SPBRes.InvalidTokenPaginationProperties(b.ToString("x", CultureInfo.InvariantCulture)));
}
b = reader.ReadByte();
}
if (reader.BaseStream.Position > offsetEndPage)
{
throw new InvalidDataException(SPBRes.InvalidPaginationStream);
}
}
