internal void WriteStartItemToStream(RPLWriter rplWriter, PageContext pageContext)
{
if (rplWriter != null)
{
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
Stream baseStream = binaryWriter.BaseStream;
m_offset = baseStream.Position;
binaryWriter.Write((byte)10);
WriteElementProps(binaryWriter, rplWriter, pageContext, m_offset + 1);
}
else
{
m_rplElement = new RPLRectangle();
WriteElementProps(m_rplElement.ElementProps, rplWriter, pageContext);
}
}
}
internal void UpdateReportSectionSizes(RPLWriter rplWriter)
{
if (m_itemRenderSizes != null && rplWriter != null)
{
double num = m_itemRenderSizes.Width;
if (m_header != null)
{
num = Math.Max(num, m_header.ItemRenderSizes.Width);
m_itemRenderSizes.Height += m_header.ItemRenderSizes.Height;
}
if (m_footer != null)
{
num = Math.Max(num, m_footer.ItemRenderSizes.Width);
m_itemRenderSizes.Height += m_footer.ItemRenderSizes.Height;
}
m_itemRenderSizes.Width = num;
NormalizeSectionAreasWidths(rplWriter, num);
}
}
internal override void WriteCustomSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext)
{
switch (((Microsoft.ReportingServices.OnDemandReportRendering.Image)m_source).Sizing)
{
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.Clip:
spbifWriter.Write((byte)41);
spbifWriter.Write((byte)3);
break;
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.Fit:
spbifWriter.Write((byte)41);
spbifWriter.Write((byte)1);
break;
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.FitProportional:
spbifWriter.Write((byte)41);
spbifWriter.Write((byte)2);
break;
}
}
internal void WriteItemToStream(RPLWriter rplWriter, PageContext pageContext)
{
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
Stream baseStream = binaryWriter.BaseStream;
long position = baseStream.Position;
binaryWriter.Write((byte)8);
WriteElementProps(binaryWriter, rplWriter, pageContext, position + 1);
m_offset = baseStream.Position;
binaryWriter.Write((byte)254);
binaryWriter.Write(position);
binaryWriter.Write(byte.MaxValue);
}
else
{
m_rplElement = new RPLLine();
WriteElementProps(m_rplElement.ElementProps, rplWriter, pageContext);
}
}
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);
}
}
}
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 CalculateRepeatWithPage(RPLWriter rplWriter, PageContext pageContext, PageItem[] siblings)
{
AdjustOriginFromItemsAbove(siblings, null);
ItemSizes contentSize = null;
if (ResolveItemHiddenState(rplWriter, null, pageContext, createForRepeat: true, ref contentSize))
{
CalculateHiddenItemRenderSize(pageContext, createForRepeat: true);
return;
}
Microsoft.ReportingServices.OnDemandReportRendering.Rectangle rectangle = (Microsoft.ReportingServices.OnDemandReportRendering.Rectangle)m_source;
m_staticItem = CreateChildren(rectangle.ReportItemCollection, pageContext, rectangle.Width.ToMillimeters(), rectangle.Height.ToMillimeters(), rectangle.IsSimple);
m_itemsCreated = true;
contentSize?.SetPaddings(m_itemPageSizes.PaddingRight, m_itemPageSizes.PaddingBottom);
if (m_children != null)
{
double num = m_itemPageSizes.PaddingBottom;
PageItem pageItem = null;
for (int i = 0; i < m_children.Length; i++)
{
pageItem = m_children[i];
if (pageItem != null)
{
pageItem.CalculateRepeatWithPage(rplWriter, pageContext, m_children);
num = Math.Max(num, pageItem.ItemPageSizes.Bottom + m_itemPageSizes.PaddingBottom);
}
}
if (contentSize != null)
{
ConsumeWhitespaceVertical(contentSize, num, pageContext);
}
else
{
ConsumeWhitespaceVertical(m_itemPageSizes, num, pageContext);
}
}
m_itemState = State.OnPage;
CreateItemRenderSizes(contentSize, pageContext, createForRepeat: true);
CalculateRepeatWithRenderSizes(pageContext);
}
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 WriteReportPageLayoutAtStart(RPLWriter rplWriter)
{
if (m_pageContext.VersionPicker != 0 && m_pageContext.VersionPicker != RPLVersionEnum.RPL2008WithImageConsolidation && rplWriter != null)
{
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
Page page = m_report.ReportSections[0].Page;
if (binaryWriter != null)
{
Stream baseStream = binaryWriter.BaseStream;
m_pageLayoutOffset = baseStream.Position;
binaryWriter.Write((byte)3);
binaryWriter.Write((byte)16);
binaryWriter.Write((float)page.PageHeight.ToMillimeters());
binaryWriter.Write((byte)17);
binaryWriter.Write((float)page.PageWidth.ToMillimeters());
binaryWriter.Write((byte)20);
binaryWriter.Write((float)page.BottomMargin.ToMillimeters());
binaryWriter.Write((byte)19);
binaryWriter.Write((float)page.LeftMargin.ToMillimeters());
binaryWriter.Write((byte)21);
binaryWriter.Write((float)page.RightMargin.ToMillimeters());
binaryWriter.Write((byte)18);
binaryWriter.Write((float)page.TopMargin.ToMillimeters());
new ReportPageLayout(page).WriteElementStyle(rplWriter, m_pageContext);
binaryWriter.Write(byte.MaxValue);
}
else
{
RPLPageLayout rPLPageLayout = new RPLPageLayout();
rplWriter.Report.RPLPaginatedPages[0].PageLayout = rPLPageLayout;
rPLPageLayout.PageHeight = (float)page.PageHeight.ToMillimeters();
rPLPageLayout.PageWidth = (float)page.PageWidth.ToMillimeters();
rPLPageLayout.MarginBottom = (float)page.BottomMargin.ToMillimeters();
rPLPageLayout.MarginLeft = (float)page.LeftMargin.ToMillimeters();
rPLPageLayout.MarginRight = (float)page.RightMargin.ToMillimeters();
rPLPageLayout.MarginTop = (float)page.TopMargin.ToMillimeters();
new ReportPageLayout(page).WriteElementStyle(rplWriter, m_pageContext);
}
}
}
internal void WriteElementStyle(RPLWriter rplWriter, PageContext pageContext)
{
if (rplWriter == null)
{
return;
}
Style style = m_source.Style;
if (style == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
WriteSharedStyle(binaryWriter, style, pageContext, 6);
StyleInstance styleInstance = GetStyleInstance(m_source, null);
if (styleInstance != null)
{
WriteNonSharedStyle(binaryWriter, style, styleInstance, pageContext, null, null);
}
binaryWriter.Write(byte.MaxValue);
return;
}
RPLPageLayout pageLayout = rplWriter.Report.RPLPaginatedPages[0].PageLayout;
RPLStyleProps rPLStyleProps = WriteSharedStyle(style, pageContext);
RPLStyleProps rPLStyleProps2 = null;
StyleInstance styleInstance2 = GetStyleInstance(m_source, null);
if (styleInstance2 != null)
{
rPLStyleProps2 = WriteNonSharedStyle(style, styleInstance2, pageContext, null);
}
if (rPLStyleProps != null || rPLStyleProps2 != null)
{
pageLayout.Style = new RPLElementStyle(rPLStyleProps2, rPLStyleProps);
}
}
internal override int WriteRepeatWithToPage(RPLWriter rplWriter, PageContext pageContext)
{
if (base.ItemState == State.OnPageHidden)
{
return(0);
}
WriteStartItemToStream(rplWriter, pageContext);
int num = 0;
if (m_children != null)
{
for (int i = 0; i < m_children.Length; i++)
{
if (m_children[i] != null)
{
num += m_children[i].WriteRepeatWithToPage(rplWriter, pageContext);
}
}
}
WriteRepeatWithEndItemToStream(rplWriter, num);
return(1);
}
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 void WriteEndItemToStream(RPLWriter rplWriter)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
WriteEndRectangleItemToRPLStream2008(binaryWriter);
}
else
{
WriteEndSectionItemToRPLStream(binaryWriter);
}
}
else
{
WriteEndSectionItemToRPLOM(rplWriter);
}
}
internal void WriteStartItemToStream(RPLWriter rplWriter, PageContext pageContext)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
if (pageContext.VersionPicker == RPLVersionEnum.RPL2008 || pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
WriteStartItemToRPLStream2008(rplWriter, binaryWriter, pageContext);
}
else
{
WriteStartItemToRPLStream(rplWriter, binaryWriter, pageContext);
}
}
else
{
WriteStartItemToRPLOM(rplWriter, pageContext);
}
}
internal void WriteEndItemToStream(RPLWriter rplWriter, int sectionStartIndex, int itemsOnPage, PageHeadFoot header, PageHeadFoot footer, double bodyWidth, double bodyHeight, string pageName)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
if (m_pageContext.VersionPicker == RPLVersionEnum.RPL2008 || m_pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
WriteEndItemToRPLStream2008(binaryWriter, itemsOnPage, header, footer, bodyWidth, bodyHeight);
}
else
{
WriteEndItemToRPLStream(binaryWriter, pageName);
}
}
else
{
WriteEndItemToRPLOM(rplWriter, sectionStartIndex, pageName);
}
}
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 void WriteBodyColumnsToStream(RPLWriter rplWriter)
{
if (m_pageContext.VersionPicker != 0 && m_pageContext.VersionPicker != RPLVersionEnum.RPL2008WithImageConsolidation && rplWriter != null)
{
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
Stream baseStream = binaryWriter.BaseStream;
long position = baseStream.Position;
binaryWriter.Write((byte)16);
binaryWriter.Write(m_bodyOffset);
binaryWriter.Write(1);
m_body.WritePageItemRenderSizes(binaryWriter);
m_bodyOffset = baseStream.Position;
binaryWriter.Write((byte)254);
binaryWriter.Write(position);
binaryWriter.Write(byte.MaxValue);
}
else
{
m_rplReportSection.Columns[0] = m_body.WritePageItemRenderSizes();
}
}
}
internal override void WriteCustomSharedItemProps(RPLElementPropsDef sharedProps, RPLWriter rplWriter, PageContext pageContext)
{
((RPLLinePropsDef)sharedProps).Slant = ((Microsoft.ReportingServices.OnDemandReportRendering.Line)m_source).Slant;
}
internal override void WriteCustomNonSharedItemProps(RPLElementProps nonSharedProps, RPLWriter rplWriter, PageContext pageContext)
{
ActionInfoWithDynamicImageMapCollection actionImageMaps = null;
RPLDynamicImageProps rPLDynamicImageProps = (RPLDynamicImageProps)nonSharedProps;
string streamName = null;
System.Drawing.Rectangle offsets = System.Drawing.Rectangle.Empty;
rPLDynamicImageProps.DynamicImageContent = LoadDynamicImage(pageContext, ref streamName, out actionImageMaps, out offsets);
rPLDynamicImageProps.ImageConsolidationOffsets = offsets;
rPLDynamicImageProps.StreamName = streamName;
if (actionImageMaps != null)
{
rPLDynamicImageProps.ActionImageMapAreas = WriteImageMapAreaInstanceCollection(actionImageMaps, pageContext);
}
}
internal override void WriteCustomNonSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext)
{
ActionInfoWithDynamicImageMapCollection actionImageMaps = null;
string streamName = null;
System.Drawing.Rectangle offsets = System.Drawing.Rectangle.Empty;
Stream stream = LoadDynamicImage(pageContext, ref streamName, out actionImageMaps, out offsets);
if (streamName != null)
{
spbifWriter.Write((byte)40);
spbifWriter.Write(streamName);
}
if (!offsets.IsEmpty)
{
if (pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
spbifWriter.Write((byte)47);
}
else
{
spbifWriter.Write((byte)49);
}
spbifWriter.Write(offsets.Left);
spbifWriter.Write(offsets.Top);
spbifWriter.Write(offsets.Width);
spbifWriter.Write(offsets.Height);
}
if (stream != null)
{
spbifWriter.Write((byte)39);
spbifWriter.Write((int)stream.Length);
byte[] array = new byte[4096];
stream.Position = 0L;
for (int num = stream.Read(array, 0, array.Length); num != 0; num = stream.Read(array, 0, array.Length))
{
spbifWriter.Write(array, 0, num);
}
}
if (actionImageMaps != null)
{
WriteImageMapAreaInstanceCollection(actionImageMaps, spbifWriter, pageContext);
}
}
internal override void WriteNonSharedItemProps(RPLElementProps elemProps, RPLWriter rplWriter, PageContext pageContext)
{
Microsoft.ReportingServices.OnDemandReportRendering.Paragraph paragraph = m_source as Microsoft.ReportingServices.OnDemandReportRendering.Paragraph;
RSTrace.RenderingTracer.Assert(paragraph != null, "The paragraph definition cannot be null");
ParagraphInstance paragraphInstance = null;
bool flag = false;
if (m_compiledSource != null)
{
paragraphInstance = m_compiledSource;
flag = true;
}
else
{
paragraphInstance = paragraph.Instance;
RSTrace.RenderingTracer.Assert(paragraphInstance != null, "The paragraph instance cannot be null");
}
elemProps.UniqueName = paragraphInstance.UniqueName;
RPLParagraphProps rPLParagraphProps = elemProps as RPLParagraphProps;
if (!flag)
{
if (IsExpressionValue(paragraph.LeftIndent, paragraphInstance.LeftIndent))
{
rPLParagraphProps.LeftIndent = new RPLReportSize(paragraphInstance.LeftIndent.ToString());
}
if (IsExpressionValue(paragraph.RightIndent, paragraphInstance.RightIndent))
{
rPLParagraphProps.RightIndent = new RPLReportSize(paragraphInstance.RightIndent.ToString());
}
if (IsExpressionValue(paragraph.HangingIndent, paragraphInstance.HangingIndent))
{
rPLParagraphProps.HangingIndent = new RPLReportSize(paragraphInstance.HangingIndent.ToString());
}
if (paragraph.ListStyle.IsExpression)
{
rPLParagraphProps.ListStyle = (RPLFormat.ListStyles)StyleEnumConverter.Translate(paragraphInstance.ListStyle);
}
else
{
rPLParagraphProps.ListStyle = null;
}
if (paragraph.ListLevel.IsExpression)
{
rPLParagraphProps.ListLevel = paragraphInstance.ListLevel;
}
else
{
rPLParagraphProps.ListLevel = null;
}
if (IsExpressionValue(paragraph.SpaceBefore, paragraphInstance.SpaceBefore))
{
rPLParagraphProps.SpaceBefore = new RPLReportSize(paragraphInstance.SpaceBefore.ToString());
}
if (IsExpressionValue(paragraph.SpaceAfter, paragraphInstance.SpaceAfter))
{
rPLParagraphProps.SpaceAfter = new RPLReportSize(paragraphInstance.SpaceAfter.ToString());
}
}
else
{
if (paragraphInstance.LeftIndent != null)
{
rPLParagraphProps.LeftIndent = new RPLReportSize(paragraphInstance.LeftIndent.ToString());
}
if (paragraphInstance.RightIndent != null)
{
rPLParagraphProps.RightIndent = new RPLReportSize(paragraphInstance.RightIndent.ToString());
}
if (paragraphInstance.HangingIndent != null)
{
rPLParagraphProps.HangingIndent = new RPLReportSize(paragraphInstance.HangingIndent.ToString());
}
rPLParagraphProps.ListStyle = (RPLFormat.ListStyles)StyleEnumConverter.Translate(paragraphInstance.ListStyle);
rPLParagraphProps.ListLevel = paragraphInstance.ListLevel;
if (paragraphInstance.SpaceBefore != null)
{
rPLParagraphProps.SpaceBefore = new RPLReportSize(paragraphInstance.SpaceBefore.ToString());
}
if (paragraphInstance.SpaceAfter != null)
{
rPLParagraphProps.SpaceAfter = new RPLReportSize(paragraphInstance.SpaceAfter.ToString());
}
}
rPLParagraphProps.ParagraphNumber = m_paragraphNumber;
rPLParagraphProps.NonSharedStyle = WriteNonSharedStyle(null, null, pageContext, m_compiledSource);
}
internal override void WriteNonSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext)
{
Microsoft.ReportingServices.OnDemandReportRendering.Paragraph paragraph = m_source as Microsoft.ReportingServices.OnDemandReportRendering.Paragraph;
RSTrace.RenderingTracer.Assert(paragraph != null, "The paragraph definition cannot be null");
ParagraphInstance paragraphInstance = null;
bool flag = false;
if (m_compiledSource != null)
{
paragraphInstance = m_compiledSource;
flag = true;
}
else
{
paragraphInstance = paragraph.Instance;
RSTrace.RenderingTracer.Assert(paragraphInstance != null, "The paragraph instance cannot be null");
}
spbifWriter.Write((byte)1);
spbifWriter.Write((byte)4);
spbifWriter.Write(paragraphInstance.UniqueName);
if (!flag)
{
if (IsExpressionValue(paragraph.LeftIndent, paragraphInstance.LeftIndent))
{
spbifWriter.Write((byte)9);
spbifWriter.Write(paragraphInstance.LeftIndent.ToString());
}
if (IsExpressionValue(paragraph.RightIndent, paragraphInstance.RightIndent))
{
spbifWriter.Write((byte)10);
spbifWriter.Write(paragraphInstance.RightIndent.ToString());
}
if (IsExpressionValue(paragraph.HangingIndent, paragraphInstance.HangingIndent))
{
spbifWriter.Write((byte)11);
spbifWriter.Write(paragraphInstance.HangingIndent.ToString());
}
if (paragraph.ListStyle.IsExpression)
{
spbifWriter.Write((byte)7);
spbifWriter.Write(StyleEnumConverter.Translate(paragraphInstance.ListStyle));
}
if (paragraph.ListLevel.IsExpression)
{
spbifWriter.Write((byte)8);
spbifWriter.Write(paragraphInstance.ListLevel);
}
if (IsExpressionValue(paragraph.SpaceBefore, paragraphInstance.SpaceBefore))
{
spbifWriter.Write((byte)12);
spbifWriter.Write(paragraphInstance.SpaceBefore.ToString());
}
if (IsExpressionValue(paragraph.SpaceAfter, paragraphInstance.SpaceAfter))
{
spbifWriter.Write((byte)13);
spbifWriter.Write(paragraphInstance.SpaceAfter.ToString());
}
}
else
{
if (paragraphInstance.LeftIndent != null)
{
spbifWriter.Write((byte)9);
spbifWriter.Write(paragraphInstance.LeftIndent.ToString());
}
if (paragraphInstance.RightIndent != null)
{
spbifWriter.Write((byte)10);
spbifWriter.Write(paragraphInstance.RightIndent.ToString());
}
if (paragraphInstance.HangingIndent != null)
{
spbifWriter.Write((byte)11);
spbifWriter.Write(paragraphInstance.HangingIndent.ToString());
}
spbifWriter.Write((byte)7);
spbifWriter.Write(StyleEnumConverter.Translate(paragraphInstance.ListStyle));
spbifWriter.Write((byte)8);
spbifWriter.Write(paragraphInstance.ListLevel);
if (paragraphInstance.SpaceBefore != null)
{
spbifWriter.Write((byte)12);
spbifWriter.Write(paragraphInstance.SpaceBefore.ToString());
}
if (paragraphInstance.SpaceAfter != null)
{
spbifWriter.Write((byte)13);
spbifWriter.Write(paragraphInstance.SpaceAfter.ToString());
}
}
if (m_paragraphNumber > 0)
{
spbifWriter.Write((byte)14);
spbifWriter.Write(m_paragraphNumber);
}
WriteNonSharedStyle(spbifWriter, null, null, pageContext, 6, m_compiledSource);
spbifWriter.Write(byte.MaxValue);
}
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 void WriteStartItemToStream(RPLWriter rplWriter, PageContext pageContext)
{
if (rplWriter == null)
{
return;
}
BinaryWriter binaryWriter = rplWriter.BinaryWriter;
if (binaryWriter != null)
{
Stream baseStream = binaryWriter.BaseStream;
m_offset = baseStream.Position;
if (pageContext.VersionPicker == RPLVersionEnum.RPL2008 || pageContext.VersionPicker == RPLVersionEnum.RPL2008WithImageConsolidation)
{
binaryWriter.Write((byte)10);
}
else
{
binaryWriter.Write((byte)6);
}
binaryWriter.Write((byte)15);
binaryWriter.Write((byte)0);
binaryWriter.Write((byte)1);
binaryWriter.Write(SourceID);
Style style = m_source.Style;
if (style != null)
{
WriteSharedStyle(binaryWriter, style, pageContext, 6);
binaryWriter.Write(byte.MaxValue);
binaryWriter.Write((byte)1);
binaryWriter.Write((byte)0);
binaryWriter.Write(SourceUniqueName);
StyleInstance styleInstance = GetStyleInstance(m_source, null);
if (styleInstance != null)
{
WriteNonSharedStyle(binaryWriter, style, styleInstance, pageContext, 6, null);
}
}
else
{
binaryWriter.Write(byte.MaxValue);
binaryWriter.Write((byte)1);
binaryWriter.Write((byte)0);
binaryWriter.Write(SourceUniqueName);
}
binaryWriter.Write(byte.MaxValue);
binaryWriter.Write(byte.MaxValue);
return;
}
m_rplElement = new RPLBody();
m_rplElement.ElementProps.Definition.ID = SourceID;
m_rplElement.ElementProps.UniqueName = SourceUniqueName;
Style style2 = m_source.Style;
if (style2 != null)
{
m_rplElement.ElementProps.Definition.SharedStyle = WriteSharedStyle(style2, pageContext);
StyleInstance styleInstance2 = GetStyleInstance(m_source, null);
if (styleInstance2 != null)
{
m_rplElement.ElementProps.NonSharedStyle = WriteNonSharedStyle(style2, styleInstance2, pageContext, null);
}
}
}
internal override void WriteCustomNonSharedItemProps(RPLElementProps nonSharedProps, RPLWriter rplWriter, PageContext pageContext)
{
Microsoft.ReportingServices.OnDemandReportRendering.Image image = (Microsoft.ReportingServices.OnDemandReportRendering.Image)m_source;
ImageInstance imageInstance = (ImageInstance)image.Instance;
System.Drawing.Image gdiImage = null;
RPLImageProps rPLImageProps = (RPLImageProps)nonSharedProps;
if (AutoSizeImage(pageContext, imageInstance, out gdiImage))
{
WriteImage(null, "InvalidImage", rPLImageProps, pageContext, gdiImage);
}
else
{
WriteImage(imageInstance, null, rPLImageProps, pageContext, gdiImage);
}
rPLImageProps.ActionInfo = WriteActionInfo(image.ActionInfo, pageContext);
rPLImageProps.ActionImageMapAreas = WriteImageMapAreaInstanceCollection(imageInstance.ActionInfoWithDynamicImageMapAreas, pageContext);
}
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 void WriteCustomSharedItemProps(RPLElementPropsDef sharedProps, RPLWriter rplWriter, PageContext pageContext)
{
Microsoft.ReportingServices.OnDemandReportRendering.Image obj = (Microsoft.ReportingServices.OnDemandReportRendering.Image)m_source;
RPLImagePropsDef rPLImagePropsDef = (RPLImagePropsDef)sharedProps;
switch (obj.Sizing)
{
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.AutoSize:
rPLImagePropsDef.Sizing = RPLFormat.Sizings.AutoSize;
break;
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.Clip:
rPLImagePropsDef.Sizing = RPLFormat.Sizings.Clip;
break;
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.Fit:
rPLImagePropsDef.Sizing = RPLFormat.Sizings.Fit;
break;
case Microsoft.ReportingServices.OnDemandReportRendering.Image.Sizings.FitProportional:
rPLImagePropsDef.Sizing = RPLFormat.Sizings.FitProportional;
break;
}
}
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 void WriteCustomNonSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext)
{
Microsoft.ReportingServices.OnDemandReportRendering.Image image = (Microsoft.ReportingServices.OnDemandReportRendering.Image)m_source;
ImageInstance imageInstance = (ImageInstance)image.Instance;
System.Drawing.Image gdiImage = null;
bool flag = AutoSizeImage(pageContext, imageInstance, out gdiImage);
try
{
if (flag)
{
WriteImage(null, "InvalidImage", spbifWriter, pageContext, gdiImage);
}
else
{
WriteImage(imageInstance, null, spbifWriter, pageContext, gdiImage);
}
}
finally
{
if (gdiImage != null)
{
gdiImage.Dispose();
gdiImage = null;
}
}
WriteActionInfo(image.ActionInfo, spbifWriter, pageContext, 7);
WriteImageMapAreaInstanceCollection(imageInstance.ActionInfoWithDynamicImageMapAreas, spbifWriter, pageContext);
}
internal override void WriteSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext, long offset)
{
Microsoft.ReportingServices.OnDemandReportRendering.Paragraph paragraph = m_source as Microsoft.ReportingServices.OnDemandReportRendering.Paragraph;
RSTrace.RenderingTracer.Assert(paragraph != null, "The paragraph definition cannot be null");
Hashtable hashtable = pageContext.ItemPropsStart;
if (hashtable != null)
{
object obj = hashtable[SourceID];
if (obj != null)
{
spbifWriter.Write((byte)2);
spbifWriter.Write((long)obj);
return;
}
}
if (hashtable == null)
{
hashtable = (pageContext.ItemPropsStart = new Hashtable());
}
hashtable.Add(SourceID, offset);
spbifWriter.Write((byte)0);
spbifWriter.Write((byte)5);
spbifWriter.Write(SourceID);
if (IsNotExpressionValue(paragraph.LeftIndent))
{
spbifWriter.Write((byte)9);
spbifWriter.Write(paragraph.LeftIndent.Value.ToString());
}
if (IsNotExpressionValue(paragraph.RightIndent))
{
spbifWriter.Write((byte)10);
spbifWriter.Write(paragraph.RightIndent.Value.ToString());
}
if (IsNotExpressionValue(paragraph.HangingIndent))
{
spbifWriter.Write((byte)11);
spbifWriter.Write(paragraph.HangingIndent.Value.ToString());
}
if (!paragraph.ListStyle.IsExpression)
{
spbifWriter.Write((byte)7);
spbifWriter.Write(StyleEnumConverter.Translate(paragraph.ListStyle.Value));
}
if (!paragraph.ListLevel.IsExpression)
{
spbifWriter.Write((byte)8);
spbifWriter.Write(paragraph.ListLevel.Value);
}
if (IsNotExpressionValue(paragraph.SpaceBefore))
{
spbifWriter.Write((byte)12);
spbifWriter.Write(paragraph.SpaceBefore.Value.ToString());
}
if (IsNotExpressionValue(paragraph.SpaceAfter))
{
spbifWriter.Write((byte)13);
spbifWriter.Write(paragraph.SpaceAfter.Value.ToString());
}
WriteSharedStyle(spbifWriter, null, pageContext, 6);
spbifWriter.Write(byte.MaxValue);
}
