public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
{
RPLElementProps elementProps = reportItem.ElementProps;
RPLElementPropsDef definition = elementProps.Definition;
RenderRectangle((RPLContainer)reportItem, elementProps, definition, measurement, ref borderContext, renderId, styleContext, treatAsTopLevel);
}
private Rectangle RenderDynamicImage(RPLItemMeasurement measurement, RPLDynamicImageProps dynamicImageProps)
{
if (html5Renderer.m_createSecondaryStreams != 0)
{
return(dynamicImageProps.ImageConsolidationOffsets);
}
Stream stream = null;
stream = html5Renderer.CreateStream(dynamicImageProps.StreamName, "png", null, "image/png", willSeek: false, StreamOper.CreateAndRegister);
if (dynamicImageProps.DynamicImageContentOffset >= 0)
{
html5Renderer.m_rplReport.GetImage(dynamicImageProps.DynamicImageContentOffset, stream);
}
else if (dynamicImageProps.DynamicImageContent != null)
{
byte[] array = new byte[4096];
dynamicImageProps.DynamicImageContent.Position = 0L;
int num = (int)dynamicImageProps.DynamicImageContent.Length;
while (num > 0)
{
int num2 = dynamicImageProps.DynamicImageContent.Read(array, 0, Math.Min(array.Length, num));
stream.Write(array, 0, num2);
num -= num2;
}
}
return(Rectangle.Empty);
}
public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
{
RPLElementProps elementProps = reportItem.ElementProps;
RPLElementPropsDef definition = elementProps.Definition;
this.RenderLine((RPLLine)reportItem, elementProps, (RPLLinePropsDef)definition, measurement, renderId, styleContext);
}
internal virtual void Initialize(GdiContext context, RPLItemMeasurement measurement, RectangleF bounds, string accessibleName)
{
Initialize(measurement.Element);
m_accessibleName = accessibleName;
m_zIndex = measurement.ZIndex;
m_state = measurement.State;
m_position = GdiContext.GetMeasurementRectangle(measurement, bounds);
if (!string.IsNullOrEmpty(Label))
{
context.RenderingReport.Labels.Add(InstanceProperties.UniqueName, new LabelPoint(base.Position.Location));
}
if (!string.IsNullOrEmpty(Bookmark))
{
context.RenderingReport.Bookmarks.Add(InstanceProperties.UniqueName, new BookmarkPoint(base.Position.Location));
}
if (!string.IsNullOrEmpty(ToolTip))
{
context.RenderingReport.ToolTips.Add(new ReportToolTip(InstanceProperties.UniqueName, base.Position, ToolTip));
}
ProcessRenderingElementContent(measurement.Element, context, base.Position);
ProcessBackgroundColorAndImage(context, InstanceProperties);
if (!(this is RenderingLine))
{
ProcessBorders(context.GdiWriter, InstanceProperties as RPLItemProps, bounds, m_state);
}
if (!(InstanceProperties is RPLTextBoxProps))
{
InstanceProperties.NonSharedStyle = null;
}
}
protected override void RenderTablixCell(RPLTablix tablix, float left, float[] widths, TablixGhostCell[] ghostCells, BorderContext borderContext, int nextCell, RPLTablixCell cell, List <RPLTablixMemberCell> .Enumerator omittedCells, bool lastCell)
{
RPLItemMeasurement tablixCellMeasurement = GetTablixCellMeasurement(cell, nextCell, widths, ghostCells, omittedCells, lastCell, tablix);
RenderTablixCellItem(cell, widths, tablixCellMeasurement, left, borderContext);
ClearTablixCellBorders(cell);
FinishRenderingTablixCell(cell, widths, ghostCells, borderContext);
}
public void MarkCellUsed(RPLItemMeasurement measurement, int colSpan, int rowSpan, int index)
{
this.m_colSpan = colSpan;
this.m_rowSpan = rowSpan;
this.m_usedCell = index;
this.m_measurement = measurement;
this.m_fInUse = true;
}
internal void MarkCellUsed(RPLItemMeasurement measurement, int colSpan, int rowSpan, int index)
{
m_colSpan = colSpan;
m_rowSpan = rowSpan;
m_usedCell = index;
m_measurement = measurement;
m_fInUse = true;
}
public override bool Render()
{
RPLItemMeasurement rPLItemMeasurement = null;
bool flag = true;
string author = "";
string title = "";
string description = "";
AutoFit autoFit = base.m_writer.AutoFit;
float num = 0f;
float leftMargin = 0f;
float rightMargin = 0f;
RPLPageLayout rPLPageLayout = null;
List <RPLReport> rplReportCache = new List <RPLReport>();
bool flag2 = false;
bool flag3 = false;
SectionEntry sectionEntry = null;
while (!base.m_spbProcessing.Done)
{
if (!flag)
{
base.m_writer.WritePageBreak();
}
base.m_spbProcessing.GetNextPage(out base.m_rplReport);
RPLPageContent rPLPageContent = base.m_rplReport.RPLPaginatedPages[0];
RPLReportSection rPLReportSection = rPLPageContent.GetNextReportSection();
bool flag4 = false;
bool flag5 = true;
while (rPLReportSection != null)
{
rPLItemMeasurement = rPLReportSection.Columns[0];
float width = rPLReportSection.BodyArea.Width;
RPLHeaderFooter footer = null;
SectionEntry se = null;
if (!flag5 || sectionEntry == null || string.CompareOrdinal(sectionEntry.SectionId, rPLReportSection.ID) != 0)
{
if (RSTrace.RenderingTracer.TraceVerbose)
{
RSTrace.RenderingTracer.Trace("The left or right margin is either <0 or the sum exceeds the page width.");
}
sectionEntry = (se = this.RenderHeaderFooters(rPLReportSection, flag5, ref flag4, rplReportCache, ref footer, ref flag2, ref flag3));
}
flag = base.SetFirstPageDimensions(flag, rPLPageContent, ref rPLPageLayout, ref leftMargin, ref rightMargin, ref num, ref title, ref author, ref description);
num = base.RevisePageDimensions(leftMargin, rightMargin, num, width, autoFit);
base.RenderHeaderBetweenSections(rPLReportSection, flag5);
base.RenderBodyContent(width, rPLItemMeasurement);
rPLReportSection = base.AdvanceToNextSection(rPLPageContent, rPLReportSection, ref flag5, sectionEntry, footer, se);
}
if (!base.m_spbProcessing.Done && !flag4)
{
base.m_rplReport.Release();
}
}
base.m_writer.WriteParagraphEnd();
base.m_writer.SetPageDimensions(base.m_pageHeight, num, leftMargin, rightMargin, rPLPageLayout.MarginTop, rPLPageLayout.MarginBottom);
base.FinishRendering(rplReportCache, title, author, description);
return(true);
}
internal override bool Render()
{
RPLItemMeasurement rPLItemMeasurement = null;
bool flag = true;
string author = "";
string title = "";
string description = "";
AutoFit autoFit = m_writer.AutoFit;
float width = 0f;
float leftMargin = 0f;
float rightMargin = 0f;
RPLPageLayout rplPageLayout = null;
List <RPLReport> rplReportCache = new List <RPLReport>();
bool hasHeaderSoFar = false;
bool hasFooterSoFar = false;
SectionEntry sectionEntry = null;
while (!m_spbProcessing.Done)
{
if (!flag)
{
m_writer.WritePageBreak();
}
m_spbProcessing.GetNextPage(out m_rplReport);
RPLPageContent rPLPageContent = m_rplReport.RPLPaginatedPages[0];
RPLReportSection rPLReportSection = rPLPageContent.GetNextReportSection();
bool pageCached = false;
bool firstSection = true;
while (rPLReportSection != null)
{
rPLItemMeasurement = rPLReportSection.Columns[0];
float width2 = rPLReportSection.BodyArea.Width;
RPLHeaderFooter footer = null;
SectionEntry se = null;
if (!firstSection || sectionEntry == null || string.CompareOrdinal(sectionEntry.SectionId, rPLReportSection.ID) != 0)
{
if (RSTrace.RenderingTracer.TraceVerbose)
{
RSTrace.RenderingTracer.Trace("The left or right margin is either <0 or the sum exceeds the page width.");
}
sectionEntry = (se = RenderHeaderFooters(rPLReportSection, firstSection, ref pageCached, rplReportCache, ref footer, ref hasHeaderSoFar, ref hasFooterSoFar));
}
flag = SetFirstPageDimensions(flag, rPLPageContent, ref rplPageLayout, ref leftMargin, ref rightMargin, ref width, ref title, ref author, ref description);
width = RevisePageDimensions(leftMargin, rightMargin, width, width2, autoFit);
RenderHeaderBetweenSections(rPLReportSection, firstSection);
RenderBodyContent(width2, rPLItemMeasurement);
rPLReportSection = AdvanceToNextSection(rPLPageContent, rPLReportSection, ref firstSection, sectionEntry, footer, se);
}
if (!m_spbProcessing.Done && !pageCached)
{
m_rplReport.Release();
}
}
m_writer.WriteParagraphEnd();
m_writer.SetPageDimensions(m_pageHeight, width, leftMargin, rightMargin, rplPageLayout.MarginTop, rplPageLayout.MarginBottom);
FinishRendering(rplReportCache, title, author, description);
return(true);
}
private void WriteEndItemToRPLOM(RPLWriter rplWriter)
{
RPLItemMeasurement[] array = new RPLItemMeasurement[this.m_bodiesOnPage];
((RPLContainer)base.m_rplElement).Children = array;
for (int i = 0; i < this.m_bodiesOnPage; i++)
{
array[i] = this.m_childrenBody[i + this.m_bodyIndex].WritePageItemRenderSizes();
}
}
internal override void WriteEndItemToStream(RPLWriter rplWriter, int itemsOnPage, PageItem[] childrenOnPage)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
int num = (childrenOnPage != null) ? childrenOnPage.Length : 0;
long value = 0L;
RPLItemMeasurement[] array = null;
if (binaryWriter != null)
{
value = binaryWriter.BaseStream.Position;
binaryWriter.Write((byte)16);
binaryWriter.Write(m_offset);
binaryWriter.Write(itemsOnPage);
}
else if (itemsOnPage > 0)
{
array = new RPLItemMeasurement[itemsOnPage];
((RPLContainer)m_rplElement).Children = array;
}
PageItem pageItem = null;
int num2 = 0;
for (int i = 0; i < num; i++)
{
pageItem = childrenOnPage[i];
if (pageItem == null || pageItem.ItemState == State.Below || pageItem.ItemState == State.TopNextPage)
{
continue;
}
if (pageItem.ItemState != State.OnPageHidden && !(pageItem is NoRowsItem))
{
if (binaryWriter != null)
{
pageItem.WritePageItemRenderSizes(binaryWriter);
}
else
{
array[num2] = pageItem.WritePageItemRenderSizes();
num2++;
}
}
childrenOnPage[i] = null;
m_children[i] = null;
}
if (binaryWriter != null)
{
m_offset = binaryWriter.BaseStream.Position;
binaryWriter.Write((byte)254);
binaryWriter.Write(value);
binaryWriter.Write(byte.MaxValue);
}
}
private static void FillYArray(RPLItemMeasurement[] repItemColl, float parentHeight, List <float> topPosition, float delta)
{
int num = 0;
int num2 = 0;
RoundedFloat roundedFloat = new RoundedFloat(0f);
int num3 = 0;
RPLItemMeasurement rPLItemMeasurement = null;
if (repItemColl != null && topPosition != null)
{
topPosition.Add(roundedFloat.Value);
while (num3 < repItemColl.Length)
{
rPLItemMeasurement = repItemColl[num3];
if (PageTableLayout.SkipReportItem(rPLItemMeasurement))
{
num3++;
}
else
{
RoundedFloat roundedFloat2 = new RoundedFloat(rPLItemMeasurement.Top - delta);
while (num > 0 && roundedFloat2 < topPosition[num])
{
num--;
}
if (num < 0 || roundedFloat2 != topPosition[num])
{
topPosition.Insert(num + 1, roundedFloat2.Value - delta);
num2++;
}
num = num2;
roundedFloat.Value = PageTableLayout.ReportItemBottomValue(rPLItemMeasurement) - delta;
while (num > 0 && roundedFloat < topPosition[num])
{
num--;
}
if (num < 0 || roundedFloat != topPosition[num])
{
topPosition.Insert(num + 1, roundedFloat.Value);
num2++;
}
num = num2;
num3++;
}
}
RoundedFloat x = new RoundedFloat(parentHeight - delta);
if (!(x > topPosition[num]) && 1 != topPosition.Count)
{
return;
}
topPosition.Insert(num + 1, parentHeight - delta);
}
}
public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
{
RPLSubReport rPLSubReport = (RPLSubReport)reportItem;
RPLElementProps elementProps = reportItem.ElementProps;
RPLElementPropsDef definition = elementProps.Definition;
using (html5Renderer.m_reportContext.EnterSubreport(definition))
{
if (!styleContext.InTablix || renderId)
{
styleContext.RenderMeasurements = false;
html5Renderer.WriteStream(HTMLElements.m_openDiv);
html5Renderer.RenderReportItemStyle(rPLSubReport, elementProps, definition, measurement, styleContext, ref borderContext, definition.ID);
if (renderId)
{
html5Renderer.RenderReportItemId(elementProps.UniqueName);
}
html5Renderer.WriteStreamCR(HTMLElements.m_closeBracket);
}
RPLItemMeasurement[] children = rPLSubReport.Children;
int num = 0;
int num2 = borderContext;
bool usePercentWidth = children.Length != 0;
int num3 = children.Length;
for (int i = 0; i < num3; i++)
{
if (i == 0 && num3 > 1 && (borderContext & 8) > 0)
{
num2 &= -9;
}
else if (i == 1 && (borderContext & 4) > 0)
{
num2 &= -5;
}
if (i > 0 && i == num3 - 1 && (borderContext & 8) > 0)
{
num2 |= 8;
}
num = num2;
RPLItemMeasurement rPLItemMeasurement = children[i];
RPLContainer rPLContainer = (RPLContainer)rPLItemMeasurement.Element;
RPLElementProps elementProps2 = rPLContainer.ElementProps;
RPLElementPropsDef definition2 = elementProps2.Definition;
html5Renderer.m_isBody = true;
html5Renderer.m_usePercentWidth = usePercentWidth;
new RectangleRenderer(html5Renderer).RenderReportItem(rPLContainer, rPLItemMeasurement, new StyleContext(), ref num, renderId: false, treatAsTopLevel);
}
if (!styleContext.InTablix || renderId)
{
html5Renderer.WriteStreamCR(HTMLElements.m_closeDiv);
}
}
}
private static void FillXArray(RPLItemMeasurement[] reportItemCol, float parentWidth, List <float> leftPosition)
{
int num = 0;
int num2 = 0;
RoundedFloat roundedFloat = new RoundedFloat(0f);
RPLItemMeasurement rPLItemMeasurement = null;
int num3 = 0;
if (reportItemCol != null && leftPosition != null)
{
leftPosition.Add(roundedFloat.Value);
while (num3 < reportItemCol.Length)
{
rPLItemMeasurement = reportItemCol[num3];
if (PageTableLayout.SkipReportItem(rPLItemMeasurement))
{
num3++;
}
else
{
RoundedFloat x = new RoundedFloat(rPLItemMeasurement.Left);
while (num > 0 && x < leftPosition[num])
{
num--;
}
if (num < 0 || x != leftPosition[num])
{
leftPosition.Insert(num + 1, rPLItemMeasurement.Left);
num2++;
}
num = num2;
roundedFloat.Value = PageTableLayout.ReportItemRightValue(rPLItemMeasurement);
while (num > 0 && roundedFloat < leftPosition[num])
{
num--;
}
if (num < 0 || roundedFloat != leftPosition[num])
{
leftPosition.Insert(num + 1, roundedFloat.Value);
num2++;
}
num = num2;
num3++;
}
}
RoundedFloat x2 = new RoundedFloat(parentWidth);
if (!(x2 > leftPosition[num]) && 1 != leftPosition.Count)
{
return;
}
leftPosition.Insert(num + 1, parentWidth);
}
}
private void WriteImpl()
{
Version rPLVersion = new Version(10, 6, 0);
RPLReport rPLReport = new RPLReport();
rPLReport.ReportName = base.Report.Name;
rPLReport.Description = base.Report.Description;
rPLReport.Author = base.Report.Author;
rPLReport.AutoRefresh = base.Report.AutoRefresh;
rPLReport.ExecutionTime = base.Report.ExecutionTime;
rPLReport.Location = base.Report.Location.ToString();
rPLReport.Language = Microsoft.ReportingServices.Rendering.HPBProcessing.Report.GetReportLanguage(base.Report);
rPLReport.RPLVersion = rPLVersion;
rPLReport.RPLPaginatedPages = new RPLPageContent[1];
base.RplWriter.Report = rPLReport;
RPLReportSection rPLReportSection = new RPLReportSection(1);
rPLReportSection.ID = base.ReportSection.ID;
rPLReportSection.ColumnCount = 1;
RPLBody rPLBody = new RPLBody();
RPLItemMeasurement rPLItemMeasurement = new RPLItemMeasurement();
rPLItemMeasurement.Left = 0f;
rPLItemMeasurement.Top = 0f;
rPLItemMeasurement.Width = base.Width;
rPLItemMeasurement.Height = base.Height;
rPLItemMeasurement.ZIndex = 0;
rPLItemMeasurement.State = 0;
rPLItemMeasurement.Element = rPLBody;
rPLReportSection.Columns[0] = rPLItemMeasurement;
rPLReportSection.BodyArea = new RPLMeasurement();
rPLReportSection.BodyArea.Top = 0f;
rPLReportSection.BodyArea.Height = base.Height;
m_pageItem.WriteStartItemToStream(base.RplWriter, base.PageContext);
RPLItemMeasurement[] array2 = rPLBody.Children = new RPLItemMeasurement[1];
array2[0] = m_pageItem.WritePageItemSizes();
RPLPageLayout rPLPageLayout = new RPLPageLayout();
rPLPageLayout.PageHeight = base.Height;
rPLPageLayout.PageWidth = base.Width;
rPLPageLayout.Style = new RPLElementStyle(null, null);
RPLPageContent rPLPageContent = new RPLPageContent(1, rPLPageLayout);
RPLMeasurement rPLMeasurement = new RPLMeasurement();
rPLMeasurement.Left = 0f;
rPLMeasurement.Top = 0f;
rPLMeasurement.Width = base.Width;
rPLMeasurement.Height = base.Height;
rPLPageContent.ReportSectionSizes[0] = rPLMeasurement;
rPLPageContent.AddReportSection(rPLReportSection);
base.RplWriter.Report.RPLPaginatedPages[0] = rPLPageContent;
}
public RPLItemMeasurement WriteMeasurement()
{
RPLItemMeasurement rPLItemMeasurement = new RPLItemMeasurement();
rPLItemMeasurement.Left = (float)this.Left;
rPLItemMeasurement.Top = (float)this.Top;
rPLItemMeasurement.Width = (float)this.Width;
rPLItemMeasurement.Height = (float)this.Height;
rPLItemMeasurement.ZIndex = 0;
rPLItemMeasurement.State = 0;
rPLItemMeasurement.Element = this.Element;
return(rPLItemMeasurement);
}
protected override void RenderTextBox(RPLTextBox textBox, RPLItemMeasurement measurement, int cellIndex, float left, BorderContext borderContext, bool inTablix, bool hasBorder)
{
RPLTextBoxPropsDef textBoxPropsDef;
bool isSimple;
string textBoxValue;
bool notCanGrow;
bool needsTable;
RPLElementStyle style;
int oldCellIndex;
RPLTextBoxProps textBoxProperties = GetTextBoxProperties(textBox, out textBoxPropsDef, out isSimple, out textBoxValue, inTablix, out notCanGrow, hasBorder, cellIndex, out needsTable, out style, out oldCellIndex);
RenderTextBoxProperties(inTablix, cellIndex, needsTable, style);
RenderTextBox(textBox, inTablix, cellIndex, needsTable, style, measurement, notCanGrow, textBoxPropsDef, textBoxProperties, isSimple, textBoxValue, borderContext, oldCellIndex);
}
private static void FillXArray(RPLItemMeasurement[] reportItemCol, float parentWidth, List <float> leftPosition)
{
int num = 0;
int num2 = 0;
RoundedFloat roundedFloat = new RoundedFloat(0f);
RPLItemMeasurement rPLItemMeasurement = null;
int num3 = 0;
if (reportItemCol == null || leftPosition == null)
{
return;
}
leftPosition.Add(roundedFloat.Value);
while (num3 < reportItemCol.Length)
{
rPLItemMeasurement = reportItemCol[num3];
if (SkipReportItem(rPLItemMeasurement))
{
num3++;
continue;
}
RoundedFloat x = new RoundedFloat(rPLItemMeasurement.Left);
while (num > 0 && x < leftPosition[num])
{
num--;
}
if (num < 0 || x != leftPosition[num])
{
leftPosition.Insert(num + 1, rPLItemMeasurement.Left);
num2++;
}
num = num2;
roundedFloat.Value = ReportItemRightValue(rPLItemMeasurement);
while (num > 0 && roundedFloat < leftPosition[num])
{
num--;
}
if (num < 0 || roundedFloat != leftPosition[num])
{
leftPosition.Insert(num + 1, roundedFloat.Value);
num2++;
}
num = num2;
num3++;
}
if (new RoundedFloat(parentWidth) > leftPosition[num] || 1 == leftPosition.Count)
{
leftPosition.Insert(num + 1, parentWidth);
}
}
internal virtual void WriteEndItemToStream(RPLWriter rplWriter, List <PageItem> itemsOnPage)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
int num = itemsOnPage?.Count ?? 0;
long value = 0L;
RPLItemMeasurement[] array = null;
if (binaryWriter != null)
{
value = binaryWriter.BaseStream.Position;
binaryWriter.Write((byte)16);
binaryWriter.Write(m_offset);
binaryWriter.Write(num);
}
else
{
array = new RPLItemMeasurement[num];
((RPLContainer)m_rplElement).Children = array;
}
if (itemsOnPage != null)
{
for (int i = 0; i < num; i++)
{
PageItem pageItem = itemsOnPage[i];
if (pageItem != null)
{
if (binaryWriter != null)
{
pageItem.WritePageItemSizes(binaryWriter);
}
else
{
array[i] = pageItem.WritePageItemSizes();
}
}
}
}
if (binaryWriter != null)
{
m_offset = binaryWriter.BaseStream.Position;
binaryWriter.Write((byte)254);
binaryWriter.Write(value);
binaryWriter.Write(byte.MaxValue);
}
}
private void RenderRectangleMeasurements(RPLItemMeasurement measurement, IRPLStyle style)
{
float width = measurement.Width;
float height = measurement.Height;
this.html5Renderer.RenderMeasurementWidth(width, true);
if (this.html5Renderer.m_deviceInfo.IsBrowserIE && this.html5Renderer.m_deviceInfo.BrowserMode == BrowserMode.Standards && !this.html5Renderer.m_deviceInfo.IsBrowserIE6)
{
this.html5Renderer.RenderMeasurementMinHeight(height);
}
else
{
this.html5Renderer.RenderMeasurementHeight(height);
}
}
internal static bool SkipReportItem(RPLItemMeasurement measurement)
{
if (measurement.Height == 0f)
{
if (measurement.Width == 0f)
{
return(true);
}
if (!(measurement.Element is RPLLine))
{
return(true);
}
}
else if (measurement.Width == 0f && !(measurement.Element is RPLLine))
{
return(true);
}
return(false);
}
internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
{
RPLContainer rPLContainer = (RPLContainer)rplElement;
if (rPLContainer.Children == null)
{
return;
}
if (rPLContainer.Children.Length == 1)
{
RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLContainer.Children[0], bounds);
if (renderingItem != null)
{
base.Children.Add(renderingItem);
}
rPLContainer.Children = null;
return;
}
List <RPLItemMeasurement> list = new List <RPLItemMeasurement>(rPLContainer.Children.Length);
for (int i = 0; i < rPLContainer.Children.Length; i++)
{
list.Add(rPLContainer.Children[i]);
}
rPLContainer.Children = null;
RectangleF bounds2 = bounds;
for (int j = 0; j < list.Count; j++)
{
RPLItemMeasurement rPLItemMeasurement = list[j];
rPLItemMeasurement.Width = bounds.Width;
bounds2.Height = rPLItemMeasurement.Height;
RenderingItem renderingItem2 = RenderingItem.CreateRenderingItem(context, rPLItemMeasurement, bounds2);
if (renderingItem2 != null)
{
base.Children.Add(renderingItem2);
}
bounds2.Y += rPLItemMeasurement.Height;
list[j] = null;
}
}
internal RenderingReportSection(GdiContext context, RPLReportSection reportSection, RPLSizes sectionSize, int index, float width, float offsetTop)
{
m_position.Y = offsetTop;
m_position.X = sectionSize.Left;
m_position.Width = width;
m_position.Height = sectionSize.Height;
string str = index.ToString(CultureInfo.InvariantCulture);
m_accessibleName = "ReportSection" + str;
RectangleF empty = RectangleF.Empty;
if (reportSection.Header != null)
{
empty = new RectangleF(reportSection.Header.Left, reportSection.Header.Top + offsetTop, width, reportSection.Header.Height);
reportSection.Header.Width = width;
reportSection.Header.Element.ElementProps.UniqueName = "ReportSection" + str + "Header";
m_header = new RenderingHeader();
m_header.Initialize(context, reportSection.Header, empty, ReportPreviewStrings.ReportItemAccessibleNameHeader);
m_header.SetWidth(width);
offsetTop += reportSection.Header.Height;
}
RPLItemMeasurement rPLItemMeasurement = reportSection.Columns[0];
empty = new RectangleF(rPLItemMeasurement.Left, rPLItemMeasurement.Top + offsetTop, width, rPLItemMeasurement.Height);
rPLItemMeasurement.Width = width;
rPLItemMeasurement.Element.ElementProps.UniqueName = "ReportSection" + str + "Body";
m_body = new RenderingBody();
m_body.Initialize(context, rPLItemMeasurement, empty, ReportPreviewStrings.ReportItemAccessibleNameBody);
m_body.SetWidth(width);
offsetTop += rPLItemMeasurement.Height;
if (reportSection.Footer != null)
{
empty = new RectangleF(reportSection.Footer.Left, reportSection.Footer.Top + offsetTop, width, reportSection.Footer.Height);
reportSection.Footer.Width = width;
reportSection.Footer.Element.ElementProps.UniqueName = "Section" + str + "Footer";
m_footer = new RenderingFooter();
m_footer.Initialize(context, reportSection.Footer, empty, ReportPreviewStrings.ReportItemAccessibleNameFooter);
m_footer.SetWidth(width);
offsetTop += reportSection.Footer.Height;
}
}
private void WriteEndSectionItemToRPLOM(RPLWriter rplWriter)
{
RPLItemMeasurement rPLItemMeasurement = m_body.WritePageItemRenderSizes();
m_body.ItemRenderSizes = null;
m_rplReportSection.BodyArea = new RPLMeasurement();
m_rplReportSection.BodyArea.Height = rPLItemMeasurement.Height;
m_rplReportSection.BodyArea.Width = rPLItemMeasurement.Width;
m_rplReportSection.BodyArea.Top = rPLItemMeasurement.Top;
m_rplReportSection.BodyArea.Left = rPLItemMeasurement.Left;
if (m_header != null)
{
m_rplReportSection.Header = m_header.WritePageItemRenderSizes();
m_header.ItemRenderSizes = null;
}
if (m_footer != null)
{
m_rplReportSection.Footer = m_footer.WritePageItemRenderSizes();
m_footer.ItemRenderSizes = null;
}
}
internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
{
RPLTablix rPLTablix = (RPLTablix)rplElement;
FixedHeaderItem fixedHeaderItem = null;
FixedHeaderItem fixedHeaderItem2 = null;
FixedHeaderItem fixedHeaderItem3 = null;
float num = 0f;
float num2 = bounds.Top;
float[] array = null;
array = ((rPLTablix.ColumnWidths == null) ? new float[0] : new float[rPLTablix.ColumnWidths.Length]);
int[] array2 = new int[array.Length];
for (int i = 0; i < array2.Length; i++)
{
array2[i] = int.MaxValue;
}
for (int j = 0; j < array.Length; j++)
{
if (j > 0)
{
array[j] = array[j - 1] + rPLTablix.ColumnWidths[j - 1];
}
if (rPLTablix.FixedColumns[j])
{
if (fixedHeaderItem3 == null)
{
fixedHeaderItem3 = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Vertical);
fixedHeaderItem3.Bounds.X += array[j];
fixedHeaderItem3.Bounds.Width = rPLTablix.ColumnWidths[j];
}
else
{
fixedHeaderItem3.Bounds.X = Math.Min(fixedHeaderItem3.Bounds.X, base.Position.X + array[j]);
fixedHeaderItem3.Bounds.Width += rPLTablix.ColumnWidths[j];
}
}
}
if (rPLTablix.FixedRow(0))
{
fixedHeaderItem = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Horizontal);
fixedHeaderItem.Bounds.Height = 0f;
context.RenderingReport.FixedHeaders.Add(fixedHeaderItem);
}
if (fixedHeaderItem3 != null)
{
context.RenderingReport.FixedHeaders.Add(fixedHeaderItem3);
if (rPLTablix.FixedRow(0))
{
fixedHeaderItem2 = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Corner);
context.RenderingReport.FixedHeaders.Add(fixedHeaderItem2);
}
}
int num3 = 0;
int num4 = -1;
RPLTablixRow nextRow;
while ((nextRow = rPLTablix.GetNextRow()) != null)
{
if (nextRow is RPLTablixOmittedRow)
{
continue;
}
SharedRenderer.CalculateColumnZIndexes(rPLTablix, nextRow, num3, array2);
if (nextRow.OmittedHeaders != null)
{
for (int k = 0; k < nextRow.OmittedHeaders.Count; k++)
{
RPLTablixMemberCell rPLTablixMemberCell = nextRow.OmittedHeaders[k];
if (!string.IsNullOrEmpty(rPLTablixMemberCell.GroupLabel))
{
float x = bounds.X;
if (rPLTablixMemberCell.ColIndex < array.Length)
{
x = array[rPLTablixMemberCell.ColIndex];
}
context.RenderingReport.Labels.Add(rPLTablixMemberCell.UniqueName, new LabelPoint(x, num2));
}
}
}
int num5 = int.MaxValue;
for (int l = 0; l < nextRow.NumCells; l++)
{
RPLTablixCell rPLTablixCell = nextRow[l];
RPLItemMeasurement rPLItemMeasurement = new RPLItemMeasurement();
rPLItemMeasurement.Element = rPLTablixCell.Element;
rPLItemMeasurement.Left = array[rPLTablixCell.ColIndex];
rPLItemMeasurement.Top = num;
rPLItemMeasurement.Width = rPLTablix.GetColumnWidth(rPLTablixCell.ColIndex, rPLTablixCell.ColSpan);
rPLItemMeasurement.Height = rPLTablix.GetRowHeight(rPLTablixCell.RowIndex, rPLTablixCell.RowSpan);
RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLItemMeasurement, bounds);
if (renderingItem == null)
{
continue;
}
if (renderingItem is RenderingDynamicImage)
{
((RenderingDynamicImage)renderingItem).Sizing = RPLFormat.Sizings.Fit;
}
RPLTablixMemberCell rPLTablixMemberCell2 = rPLTablixCell as RPLTablixMemberCell;
if (rPLTablixMemberCell2 != null && !string.IsNullOrEmpty(rPLTablixMemberCell2.GroupLabel))
{
context.RenderingReport.Labels.Add(rPLTablixMemberCell2.UniqueName, new LabelPoint(rPLItemMeasurement.Left, rPLItemMeasurement.Top));
}
if (renderingItem.HasBorders)
{
renderingItem.DelayDrawBorders = true;
if (num3 < rPLTablix.ColumnHeaderRows && rPLTablixCell is RPLTablixCornerCell)
{
m_cornerBorders.Add(new RenderingItemBorderTablix(0, 0, rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem));
}
else
{
if (num5 == int.MaxValue)
{
num5 = SharedRenderer.CalculateRowZIndex(nextRow);
}
if (num5 == int.MaxValue)
{
num5 = num4;
}
RenderingItemBorderTablix renderingItemBorderTablix = new RenderingItemBorderTablix(num5, array2[rPLTablixCell.ColIndex], rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem);
if (rPLTablixMemberCell2 != null)
{
if (num3 < rPLTablix.ColumnHeaderRows)
{
m_columnHeaderBorders.Add(renderingItemBorderTablix);
}
else
{
renderingItemBorderTablix.CompareRowFirst = false;
m_rowHeaderBorders.Add(renderingItemBorderTablix);
}
}
else
{
m_detailCellBorders.Add(renderingItemBorderTablix);
}
}
}
base.Children.Add(renderingItem);
fixedHeaderItem?.RenderingItems.Add(renderingItem);
if (rPLTablix.FixedColumns[rPLTablixCell.ColIndex])
{
fixedHeaderItem3.RenderingItems.Add(renderingItem);
}
if (fixedHeaderItem2 != null && rPLTablixCell is RPLTablixCornerCell)
{
fixedHeaderItem2.RenderingItems.Add(renderingItem);
fixedHeaderItem2.Bounds = renderingItem.Position;
}
}
num4 = num5;
if (fixedHeaderItem != null)
{
fixedHeaderItem.Bounds.Height += rPLTablix.RowHeights[num3];
if (num3 == rPLTablix.RowHeights.Length - 1 || !rPLTablix.FixedRow(num3 + 1))
{
fixedHeaderItem = null;
}
}
num += rPLTablix.RowHeights[num3];
num2 += rPLTablix.RowHeights[num3];
num3++;
for (int m = 0; m < nextRow.NumCells; m++)
{
nextRow[m] = null;
}
}
m_detailCellBorders.Sort(new ZIndexComparer());
m_columnHeaderBorders.Sort(new ZIndexComparer());
m_rowHeaderBorders.Sort(new ZIndexComparer());
m_cornerBorders.Sort(new ZIndexComparer());
RectangleF position = base.Position;
if (array.Length != 0)
{
position.Width = array[array.Length - 1] + rPLTablix.ColumnWidths[rPLTablix.ColumnWidths.Length - 1];
}
position.Height = num;
}
public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
{
RPLImageProps rPLImageProps = (RPLImageProps)reportItem.ElementProps;
RPLImagePropsDef rPLImagePropsDef = (RPLImagePropsDef)rPLImageProps.Definition;
RPLFormat.Sizings sizing = rPLImagePropsDef.Sizing;
RPLImageData image = rPLImageProps.Image;
this.html5Renderer.GetInnerContainerHeightSubtractBorders(measurement, rPLImageProps.Style);
float innerContainerWidthSubtractBorders = this.html5Renderer.GetInnerContainerWidthSubtractBorders(measurement, rPLImageProps.Style);
string text = this.html5Renderer.GetImageUrl(true, image);
string ariaLabel = null;
string role = null;
string tooltip = this.html5Renderer.GetTooltip(rPLImageProps);
if (treatAsTopLevel)
{
ariaLabel = (string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleImageLabel : RenderRes.AccessibleImageNavigationGroupLabel(tooltip));
role = HTMLElements.m_navigationRole;
}
string altText = string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleImageLabel : tooltip;
Dictionary <string, string> dictionary = new Dictionary <string, string>();
if (this.html5Renderer.m_elementExtender.ShouldApplyToElement(treatAsTopLevel))
{
dictionary.Add(HTMLElements.m_reportItemDataName, this.html5Renderer.m_elementExtender.ApplyToElement());
dictionary.Add(HTMLElements.m_reportItemCustomAttrStr, this.html5Renderer.GetReportItemPath(rPLImagePropsDef.Name));
}
bool flag = rPLImageProps.ActionImageMapAreas != null && rPLImageProps.ActionImageMapAreas.Length > 0;
if (flag)
{
string s = HTMLElements.m_hashTag + this.html5Renderer.m_deviceInfo.HtmlPrefixId + HTMLElements.m_mapPrefixString + rPLImageProps.UniqueName;
dictionary.Add(HTMLElements.m_useMapName, HttpUtility.HtmlAttributeEncode(s));
}
if (this.html5Renderer.HasAction(rPLImageProps.ActionInfo))
{
this.RenderElementHyperlink(rPLImageProps.Style, rPLImageProps.ActionInfo.Actions[0]);
}
if (!styleContext.InTablix)
{
if (sizing == RPLFormat.Sizings.AutoSize)
{
styleContext.RenderMeasurements = false;
}
this.html5Renderer.WriteStream(HTMLElements.m_openDiv);
this.html5Renderer.RenderReportItemStyle(reportItem, (RPLElementProps)rPLImageProps, (RPLElementPropsDef)rPLImagePropsDef, measurement, styleContext, ref borderContext, rPLImagePropsDef.ID);
this.html5Renderer.WriteStream(HTMLElements.m_closeBracket);
}
if (string.IsNullOrEmpty(text))
{
text = "data:image/gif;base64," + Convert.ToBase64String(HTMLRendererResources.GetBytes("Blank.gif"));
}
HtmlElement htmlElement;
switch (sizing)
{
case RPLFormat.Sizings.FitProportional:
htmlElement = new FitProportionalImageElement(text, innerContainerWidthSubtractBorders, role, altText, ariaLabel, dictionary);
break;
case RPLFormat.Sizings.Fit:
htmlElement = new FitImageElement(text, role, altText, ariaLabel, dictionary);
break;
case RPLFormat.Sizings.Clip:
htmlElement = new ClipImageElement(text, role, altText, ariaLabel, dictionary);
break;
default:
htmlElement = new OriginalSizeImageElement(text, role, altText, ariaLabel, dictionary);
break;
}
htmlElement.Render(new Html5OutputStream(this.html5Renderer));
if (!styleContext.InTablix)
{
this.html5Renderer.WriteStream(HTMLElements.m_closeDiv);
}
if (this.html5Renderer.HasAction(rPLImageProps.ActionInfo))
{
this.html5Renderer.WriteStream(HTMLElements.m_closeA);
}
if (flag)
{
this.html5Renderer.RenderImageMapAreas(rPLImageProps.ActionImageMapAreas, (double)measurement.Width, (double)measurement.Height, rPLImageProps.UniqueName, 0, 0);
}
}
private void FillAndFindOverlap(RPLItemMeasurement[] repItemCollection, double delta)
{
bool flag = false;
int num = -1;
int num2 = -1;
int colSpans = 0;
int rowSpans = 0;
int num3 = 0;
PageTableCell pageTableCell = null;
int num4 = 0;
RPLItemMeasurement rPLItemMeasurement = null;
RPLElement rPLElement = null;
while (num4 < repItemCollection.Length)
{
num = -1;
num2 = -1;
flag = false;
rPLItemMeasurement = repItemCollection[num4];
if (SkipReportItem(rPLItemMeasurement))
{
num4++;
continue;
}
rPLElement = rPLItemMeasurement.Element;
flag = FindRItemCell(rPLItemMeasurement, ref num, ref num2, delta);
if (!flag && !(rPLElement is RPLLine))
{
num4++;
continue;
}
RPLLine rPLLine = rPLElement as RPLLine;
if (rPLLine != null)
{
RPLLinePropsDef rPLLinePropsDef = rPLLine.ElementPropsDef as RPLLinePropsDef;
float width = rPLItemMeasurement.Width;
if ((width >= 0f && width < 0.01f) || (width < 0f && width > -0.01f))
{
if (!flag)
{
int num5 = 0;
bool flag2 = true;
while (flag2 && num5 < m_nrRows)
{
if (m_tableGrid[num5 * m_nrCols].YValue == (float)((double)rPLItemMeasurement.Top - delta))
{
num2 = num5;
flag2 = false;
}
num5++;
}
num = m_nrCols - 1;
if (!flag2)
{
AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, leftBorder: false);
}
}
else
{
AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, leftBorder: true);
}
num4++;
continue;
}
width = rPLItemMeasurement.Height;
if ((width >= 0f && width < 0.01f) || (width < 0f && width > -0.01f))
{
if (!flag)
{
int num6 = 0;
bool flag3 = true;
while (flag3 && num6 < m_nrCols)
{
if (m_tableGrid[num6].XValue == rPLItemMeasurement.Left)
{
num = num6;
flag3 = false;
}
num6++;
}
num2 = m_nrRows - 1;
AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, topBorder: false);
}
else
{
AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, topBorder: true);
}
num4++;
continue;
}
}
num3 = num + m_nrCols * num2;
pageTableCell = m_tableGrid[num3];
if ((pageTableCell.InUse || pageTableCell.Eaten) && rPLElement is RPLLine && rPLItemMeasurement.Width != 0f && rPLItemMeasurement.Height != 0f)
{
num4++;
continue;
}
ComputeColRowSpan(rPLItemMeasurement, num, num2, ref colSpans, ref rowSpans);
AttachRItem(num, num2, colSpans, rowSpans, rPLItemMeasurement);
num4++;
}
}
private void AttachRItem(int xCellFound, int yCellFound, int colSpan, int rowSpan, RPLItemMeasurement measurement)
{
int num = 0;
int num2 = 0;
int index = xCellFound + yCellFound * m_nrCols;
for (num = xCellFound; num <= xCellFound + colSpan - 1; num++)
{
for (num2 = yCellFound; num2 <= yCellFound + rowSpan - 1; num2++)
{
if (num != xCellFound || num2 != yCellFound)
{
m_tableGrid[num + m_nrCols * num2].MarkCellEaten(index);
}
}
}
m_tableGrid[index].MarkCellUsed(measurement, colSpan, rowSpan, index);
}
private void RenderVMLLine(RPLLine line, RPLItemMeasurement measurement, StyleContext styleContext)
{
if (!this.hasSlantedLines)
{
this.html5Renderer.WriteStream("<?XML:NAMESPACE PREFIX=v /><?IMPORT NAMESPACE=\"v\" IMPLEMENTATION=\"#default#VML\" />");
this.hasSlantedLines = true;
}
this.html5Renderer.WriteStream(HTMLElements.m_openVGroup);
this.html5Renderer.WriteStream(HTMLElements.m_openStyle);
this.html5Renderer.WriteStream(HTMLElements.m_styleWidth);
if (styleContext.InTablix)
{
this.html5Renderer.WriteStream(HTMLElements.m_percent);
this.html5Renderer.WriteStream(HTMLElements.m_semiColon);
this.html5Renderer.WriteStream(HTMLElements.m_styleHeight);
this.html5Renderer.WriteStream(HTMLElements.m_percent);
}
else
{
this.html5Renderer.WriteRSStream(measurement.Width);
this.html5Renderer.WriteStream(HTMLElements.m_semiColon);
this.html5Renderer.WriteStream(HTMLElements.m_styleHeight);
this.html5Renderer.WriteRSStream(measurement.Height);
}
this.html5Renderer.WriteStream(HTMLElements.m_closeQuote);
this.html5Renderer.WriteStream(HTMLElements.m_openVLine);
if (((RPLLinePropsDef)line.ElementProps.Definition).Slant)
{
this.html5Renderer.WriteStream(HTMLElements.m_rightSlant);
}
else
{
this.html5Renderer.WriteStream(HTMLElements.m_leftSlant);
}
IRPLStyle style = line.ElementProps.Style;
string text = (string)style[0];
string text2 = (string)style[10];
if (text != null && text2 != null)
{
int value = new RPLReportColor(text).ToColor().ToArgb() & 0xFFFFFF;
this.html5Renderer.WriteStream(HTMLElements.m_strokeColor);
this.html5Renderer.WriteStream("#");
this.html5Renderer.WriteStream(Convert.ToString(value, 16));
this.html5Renderer.WriteStream(HTMLElements.m_quote);
this.html5Renderer.WriteStream(HTMLElements.m_strokeWeight);
this.html5Renderer.WriteStream(text2);
this.html5Renderer.WriteStream(HTMLElements.m_closeQuote);
}
string theString = "solid";
string text3 = null;
object obj = style[5];
if (obj != null)
{
string value2 = EnumStrings.GetValue((RPLFormat.BorderStyles)obj);
if (string.CompareOrdinal(value2, "dashed") == 0)
{
theString = "dash";
}
else if (string.CompareOrdinal(value2, "dotted") == 0)
{
theString = "dot";
}
if (string.CompareOrdinal(value2, "double") == 0)
{
text3 = "thinthin";
}
}
this.html5Renderer.WriteStream(HTMLElements.m_dashStyle);
this.html5Renderer.WriteStream(theString);
if (text3 != null)
{
this.html5Renderer.WriteStream(HTMLElements.m_quote);
this.html5Renderer.WriteStream(HTMLElements.m_slineStyle);
this.html5Renderer.WriteStream(text3);
}
this.html5Renderer.WriteStream(HTMLElements.m_quote);
this.html5Renderer.WriteStream(HTMLElements.m_closeTag);
this.html5Renderer.WriteStreamCR(HTMLElements.m_closeVGroup);
}
protected void RenderLine(RPLLine reportItem, RPLElementProps rplProps, RPLLinePropsDef rplPropsDef, RPLItemMeasurement measurement, bool renderId, StyleContext styleContext)
{
if (this.html5Renderer.IsLineSlanted(measurement))
{
if (renderId)
{
this.html5Renderer.RenderNavigationId(rplProps.UniqueName);
}
if (this.html5Renderer.m_deviceInfo.BrowserMode == BrowserMode.Quirks)
{
this.RenderVMLLine(reportItem, measurement, styleContext);
}
}
else
{
bool flag = measurement.Height == 0.0;
this.html5Renderer.WriteStream(HTMLElements.m_openSpan);
if (renderId)
{
this.html5Renderer.RenderReportItemId(rplProps.UniqueName);
}
int num = 0;
object obj = rplProps.Style[10];
if (obj != null)
{
this.html5Renderer.OpenStyle();
if (flag)
{
this.html5Renderer.WriteStream(HTMLElements.m_styleHeight);
}
else
{
this.html5Renderer.WriteStream(HTMLElements.m_styleWidth);
}
this.html5Renderer.WriteStream(obj);
this.html5Renderer.WriteStream(HTMLElements.m_semiColon);
}
obj = rplProps.Style[0];
if (obj != null)
{
this.html5Renderer.OpenStyle();
this.html5Renderer.WriteStream(HTMLElements.m_backgroundColor);
this.html5Renderer.WriteStream(obj);
}
this.html5Renderer.RenderReportItemStyle(reportItem, measurement, ref num);
this.html5Renderer.CloseStyle(true);
this.html5Renderer.WriteStream(HTMLElements.m_closeBracket);
this.html5Renderer.WriteStream(HTMLElements.m_closeSpan);
}
}
