internal void CalculateDelayedFooter(RPLWriter rplWriter, Interactivity interactivity)
{
PageSection pageFooter = m_reportSectionDef.Page.PageFooter;
PageContext pageContext = new PageContext(m_pageContext, PageContext.PageContextFlags.FullOnPage, PageContext.IgnorePBReasonFlag.HeaderFooter);
pageContext.RPLSectionArea = PageContext.RPLReportSectionArea.Footer;
m_footer = new PageHeadFoot(pageFooter, m_reportSectionDef.Width, pageContext);
m_footer.CalculateItem(rplWriter, pageContext, isHeader: false, interactivity, native: true);
m_itemsOnPage++;
}
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 static void AddDetailCellToCurrentPage(Microsoft.ReportingServices.OnDemandReportRendering.Tablix tablix, int colMemberIndexCell, int rowMemberIndexCell, PageContext context, bool useForPageHFEval, Interactivity interactivity)
{
if (rowMemberIndexCell >= 0)
{
TablixCell tablixCell = tablix.Body.RowCollection[rowMemberIndexCell][colMemberIndexCell];
if (tablixCell != null && tablixCell.CellContents != null)
{
RegisterItem.RegisterHiddenItem(tablixCell.CellContents.ReportItem, context, useForPageHFEval, interactivity);
}
}
}
private static bool WalkTablixMember(TablixMember tablixMember, ref bool useForPageHFEval, Interactivity interactivity)
{
if (useForPageHFEval && tablixMember.Visibility != null && tablixMember.Visibility.ToggleItem == null && tablixMember.Visibility.Hidden.IsExpression && tablixMember.Instance.Visibility.CurrentlyHidden)
{
useForPageHFEval = false;
}
if (useForPageHFEval || interactivity != null)
{
return(true);
}
return(false);
}
internal static int AddMembersToCurrentPage(Microsoft.ReportingServices.OnDemandReportRendering.Tablix tablix, TablixMember memberParent, int rowMemberIndexCell, State state, bool createDetail, bool noRows, PageContext context, bool useForPageHFEval, Interactivity interactivity)
{
TablixMemberCollection tablixMemberCollection = null;
if (memberParent == null)
{
if (state == State.RowMembers)
{
tablixMemberCollection = tablix.RowHierarchy.MemberCollection;
}
else
{
if (state == State.ColMembers)
{
AddCornerToCurrentPage(tablix.Corner, context, useForPageHFEval, interactivity);
}
tablixMemberCollection = tablix.ColumnHierarchy.MemberCollection;
}
}
else
{
tablixMemberCollection = memberParent.Children;
}
if (tablixMemberCollection == null)
{
if (state == State.RowMembers)
{
AddMembersToCurrentPage(tablix, null, memberParent.MemberCellIndex, State.DetailRows, createDetail, noRows, context, useForPageHFEval, interactivity);
}
else if (createDetail)
{
AddDetailCellToCurrentPage(tablix, memberParent.MemberCellIndex, rowMemberIndexCell, context, useForPageHFEval, interactivity);
}
if (!useForPageHFEval)
{
return(0);
}
return(1);
}
bool flag = true;
bool flag2 = true;
TablixMember tablixMember = null;
TablixMemberInstance tablixMemberInstance = null;
TablixDynamicMemberInstance tablixDynamicMemberInstance = null;
int num = 0;
bool flag3 = useForPageHFEval;
for (int i = 0; i < tablixMemberCollection.Count; i++)
{
flag3 = useForPageHFEval;
tablixMember = tablixMemberCollection[i];
if (noRows && tablixMember.HideIfNoRows)
{
if (interactivity == null)
{
continue;
}
flag3 = false;
}
flag = true;
tablixMemberInstance = tablixMember.Instance;
if (tablixMember.IsStatic)
{
flag2 = WalkTablixMember(tablixMember, ref flag3, interactivity);
}
else
{
tablixDynamicMemberInstance = (TablixDynamicMemberInstance)tablixMemberInstance;
tablixDynamicMemberInstance.ResetContext();
flag = tablixDynamicMemberInstance.MoveNext();
if (flag)
{
flag2 = WalkTablixMember(tablixMember, ref flag3, interactivity);
}
}
while (flag)
{
if (flag2)
{
int num2 = AddMembersToCurrentPage(tablix, tablixMember, rowMemberIndexCell, state, createDetail, noRows, context, flag3, interactivity);
if (state != State.DetailRows)
{
interactivity?.RegisterGroupLabel(tablixMember.Group, context);
if (tablixMember.TablixHeader != null)
{
if (num2 > 0)
{
RegisterItem.RegisterHiddenItem(tablixMember.TablixHeader.CellContents.ReportItem, context, flag3, interactivity);
num++;
}
else if (interactivity != null)
{
RegisterItem.RegisterHiddenItem(tablixMember.TablixHeader.CellContents.ReportItem, context, useForPageHFEval: false, interactivity);
}
}
}
}
if (tablixMember.IsStatic)
{
flag = false;
continue;
}
flag = tablixDynamicMemberInstance.MoveNext();
if (flag)
{
flag3 = useForPageHFEval;
flag2 = WalkTablixMember(tablixMember, ref flag3, interactivity);
}
}
tablixMemberInstance = null;
}
return(num);
}
private static void AddCornerToCurrentPage(TablixCorner corner, PageContext context, bool useForPageHFEval, Interactivity interactivity)
{
if (corner == null)
{
return;
}
TablixCornerRowCollection rowCollection = corner.RowCollection;
TablixCornerRow tablixCornerRow = null;
for (int i = 0; i < rowCollection.Count; i++)
{
tablixCornerRow = rowCollection[i];
for (int j = 0; j < tablixCornerRow.Count; j++)
{
if (tablixCornerRow[j] != null && tablixCornerRow[j].CellContents != null)
{
RegisterItem.RegisterHiddenItem(tablixCornerRow[j].CellContents.ReportItem, context, useForPageHFEval, interactivity);
}
}
}
}
private static void RegisterHiddenItem(Microsoft.ReportingServices.OnDemandReportRendering.Tablix tablix, PageContext pageContext, bool useForPageHFEval, Interactivity interactivity)
{
if (tablix != null)
{
bool flag = false;
if (useForPageHFEval)
{
flag = HeaderFooterEval.AddToCurrentPage(tablix);
}
if (flag || interactivity != null)
{
TablixInstance tablixInstance = (TablixInstance)tablix.Instance;
WalkTablix.AddMembersToCurrentPage(tablix, null, -1, WalkTablix.State.ColMembers, createDetail: false, tablixInstance.NoRows, pageContext, flag, interactivity);
WalkTablix.AddMembersToCurrentPage(tablix, null, 0, WalkTablix.State.RowMembers, createDetail: true, tablixInstance.NoRows, pageContext, flag, interactivity);
}
}
}
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);
}
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);
}
private void CalculateDelayedHeader(RPLWriter rplWriter, ReportSection firstSection, Interactivity interactivity)
{
firstSection.CalculateDelayedHeader(rplWriter, interactivity);
firstSection.UpdateReportSectionSizes(rplWriter);
firstSection.WriteEndItemToStream(rplWriter);
if (rplWriter != null)
{
m_sectionSizes[0].Height = firstSection.ItemRenderSizes.Height;
m_sectionSizes[0].Width = firstSection.ItemRenderSizes.Width;
m_sectionOffsets[0] = firstSection.Offset;
}
}
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 void CalculateItem(RPLWriter rplWriter, PageContext pageContext, bool isHeader, Interactivity interactivity, bool native)
{
WriteStartItemToStream(rplWriter, isHeader, pageContext, native);
CreateChildren(m_source.ReportItemCollection, pageContext, m_itemPageSizes.Width, m_itemPageSizes.Height);
double parentHeight = 0.0;
if (m_children != null)
{
double num = 0.0;
PageItem pageItem = null;
for (int i = 0; i < m_children.Length; i++)
{
pageItem = m_children[i];
if (pageItem != null)
{
pageItem.CalculatePage(rplWriter, null, pageContext, m_children, null, 0.0, ref parentHeight, interactivity);
num = Math.Max(num, pageItem.ItemPageSizes.Bottom + m_itemPageSizes.PaddingBottom);
}
}
ConsumeWhitespaceVertical(m_itemPageSizes, num, pageContext);
}
if (pageContext.CancelPage)
{
m_itemState = State.Below;
m_children = null;
m_rplElement = null;
return;
}
if (rplWriter != null)
{
CreateItemRenderSizes(null, pageContext, createForRepeat: false);
PageItem[] childrenOnPage = null;
int itemsOnPage = CalculateRenderSizes(rplWriter, pageContext, interactivity, null, out childrenOnPage);
WriteEndItemToStream(rplWriter, itemsOnPage, childrenOnPage);
}
m_indexesLeftToRight = null;
m_children = null;
}
internal override bool CalculatePage(RPLWriter rplWriter, PageItemHelper lastPageInfo, PageContext pageContext, PageItem[] siblings, RepeatWithItem[] repeatWithItems, double parentTopInPage, ref double parentPageHeight, Interactivity interactivity)
{
return(true);
}
internal static void RegisterPageItem(PageItem pageItem, PageContext pageContext, bool useForPageHFEval, Interactivity interactivity)
{
if (!useForPageHFEval && interactivity == null)
{
return;
}
ReportItem source = pageItem.Source;
bool flag = false;
if (useForPageHFEval)
{
if (pageItem.ItemState == PageItem.State.OnPageHidden)
{
if (source.Visibility.ToggleItem != null || !source.Visibility.Hidden.IsExpression)
{
flag = true;
}
}
else
{
Microsoft.ReportingServices.OnDemandReportRendering.TextBox textBox = source as Microsoft.ReportingServices.OnDemandReportRendering.TextBox;
if (textBox != null)
{
((TextBoxInstance)textBox.Instance).AddToCurrentPage();
}
}
}
if (interactivity != null && pageItem.ItemState != PageItem.State.OnPageHidden)
{
interactivity = null;
}
if (flag || interactivity != null)
{
RegisterHiddenItem(source, pageContext, flag, interactivity);
}
}
internal static void RegisterHiddenItem(ReportItem reportItem, PageContext pageContext, bool useForPageHFEval, Interactivity interactivity)
{
if (reportItem == null)
{
return;
}
bool flag = false;
if (useForPageHFEval)
{
flag = HeaderFooterEval.AddToCurrentPage(reportItem);
}
if (interactivity != null && !interactivity.RegisterHiddenItem(reportItem, pageContext))
{
interactivity = null;
}
if (!flag && interactivity == null)
{
return;
}
if (reportItem is Microsoft.ReportingServices.OnDemandReportRendering.TextBox)
{
if (flag)
{
Microsoft.ReportingServices.OnDemandReportRendering.TextBox textBox = reportItem as Microsoft.ReportingServices.OnDemandReportRendering.TextBox;
if (textBox != null)
{
((TextBoxInstance)textBox.Instance).AddToCurrentPage();
}
}
}
else if (reportItem is Microsoft.ReportingServices.OnDemandReportRendering.Rectangle)
{
RegisterHiddenItem(((Microsoft.ReportingServices.OnDemandReportRendering.Rectangle)reportItem).ReportItemCollection, pageContext, flag, interactivity);
}
else if (reportItem is Microsoft.ReportingServices.OnDemandReportRendering.SubReport)
{
if (interactivity == null)
{
return;
}
Microsoft.ReportingServices.OnDemandReportRendering.SubReport subReport = (Microsoft.ReportingServices.OnDemandReportRendering.SubReport)reportItem;
SubReportInstance subReportInstance = (SubReportInstance)subReport.Instance;
if (!subReportInstance.ProcessedWithError && !subReportInstance.NoRows)
{
for (int i = 0; i < subReport.Report.ReportSections.Count; i++)
{
RegisterHiddenItem(subReport.Report.ReportSections[i].Body.ReportItemCollection, pageContext, useForPageHFEval: false, interactivity);
}
}
}
else if (reportItem is Microsoft.ReportingServices.OnDemandReportRendering.Tablix)
{
RegisterHiddenItem((Microsoft.ReportingServices.OnDemandReportRendering.Tablix)reportItem, pageContext, flag, interactivity);
}
}
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);
}
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);
}
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);
}
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);
}
private static void RegisterHiddenItem(ReportItemCollection collection, PageContext pageContext, bool useForPageHFEval, Interactivity interactivity)
{
if (collection == null || collection.Count == 0)
{
return;
}
for (int i = 0; i < collection.Count; i++)
{
RegisterHiddenItem(collection[i], pageContext, useForPageHFEval, interactivity);
if (!useForPageHFEval && interactivity.Done)
{
break;
}
}
}
