public void Process(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, OnDemandProcessingContext odpContext, bool generateDocumentMap, bool createSnapshot)
{
this.m_odpContext = odpContext;
this.m_report = report;
this.m_generateDocMap = (generateDocumentMap && this.m_report.HasDocumentMap);
this.m_createSnapshot = createSnapshot;
if (this.m_generateDocMap)
{
odpContext.HasRenderFormatDependencyInDocumentMap = false;
}
if (this.m_generateDocMap || this.m_createSnapshot)
{
foreach (AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection reportSection in report.ReportSections)
{
this.Visit(reportSection);
}
}
if (this.m_generateDocMap && this.m_docMapWriter != null)
{
this.m_docMapWriter.WriteEndContainer();
this.m_docMapWriter.Close();
this.m_docMapWriter = null;
if (odpContext.HasRenderFormatDependencyInDocumentMap)
{
odpContext.OdpMetadata.ReportSnapshot.SetRenderFormatDependencyInDocumentMap(odpContext);
}
}
}
public int ProcessBookmarkNavigationEvent(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, int totalPages, string bookmarkId, out string uniqueName)
{
uniqueName = null;
if (!report.HasBookmarks)
{
return(0);
}
if (bookmarkId == null)
{
return(0);
}
int lastPageCollected = 0;
bool flag = false;
int num = InteractivityChunks.FindBoomark(report, bookmarkId, ref uniqueName, ref lastPageCollected, ref flag);
if (!flag && num == 0)
{
using (SPBProcessing sPBProcessing = new SPBProcessing(report, totalPages, true))
{
sPBProcessing.CanTracePagination = true;
sPBProcessing.SetContext(new SPBContext(0, 0, true));
return(sPBProcessing.FindBookmark(bookmarkId, lastPageCollected, ref uniqueName));
}
}
return(num);
}
public int ProcessDocumentMapNavigationEvent(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, string documentMapId)
{
if (!report.HasDocumentMap)
{
return(0);
}
if (documentMapId == null)
{
return(0);
}
int lastPageCollected = 0;
bool flag = false;
int num = InteractivityChunks.FindDocumentMapLabel(report, documentMapId, ref lastPageCollected, ref flag);
if (!flag && num == 0)
{
using (SPBProcessing sPBProcessing = new SPBProcessing(report, 0, false))
{
sPBProcessing.CanTracePagination = true;
sPBProcessing.SetContext(new SPBContext(0, 0, true));
return(sPBProcessing.FindDocumentMap(documentMapId, lastPageCollected));
}
}
return(num);
}
public ItemContext(RPLWriter rplWriter, PageContext pageContext, AspNetCore.ReportingServices.OnDemandReportRendering.Report report, AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection reportSection)
{
this.RPLWriter = rplWriter;
this.PageContext = pageContext;
this.Report = report;
this.ReportSection = reportSection;
}
private void Init(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, PaginationSettings pagination, CreateAndRegisterStream createAndRegisterStream, ref Hashtable renderProperties)
{
this.m_pageContext = new PageContext(pagination, report.AddToCurrentPage, report.ConsumeContainerWhitespace, createAndRegisterStream);
this.m_paginationSettings = pagination;
this.m_report = new Report(report, this.m_pageContext, pagination);
this.m_createAndRegisterStream = createAndRegisterStream;
if (report.SnapshotPageSizeInfo != AspNetCore.ReportingServices.OnDemandReportRendering.Report.SnapshotPageSize.Large)
{
this.m_createStream = false;
}
if (!string.IsNullOrEmpty(pagination.ReportItemPath))
{
this.m_pageContext.Common.IsInSelectiveRendering = true;
this.m_selectiveRendering = new SelectiveRendering(report, this.m_pageContext, pagination);
}
else if (this.m_totalPages <= 0)
{
this.m_totalPages = 0;
if (report.NeedsOverallTotalPages | report.NeedsPageBreakTotalPages)
{
this.m_pageContext.Common.PauseDiagnostics();
this.SetContext(0, 0);
this.m_pageContext.PropertyCacheState = PageContext.CacheState.CountPages;
while (this.NextPage())
{
}
this.m_totalPages = this.m_pageContext.PageNumber;
this.m_pageContext.Common.UpdateTotalPagesRegionMapping();
this.m_pageContext.Common.ResumeDiagnostics();
this.m_pageContext.TextBoxDuplicates = null;
}
}
}
public static DocumentMapLabels GetLabelsStream(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, int page)
{
int page2 = 0;
Stream interactivityChunck = InteractivityChunks.GetInteractivityChunck(report, "Labels", page, out page2);
if (interactivityChunck != null)
{
return(new DocumentMapLabels(interactivityChunck, page2));
}
return(null);
}
public PaginationSettings(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection aDeviceInfo)
{
this.Init(report);
int columns = default(int);
double columnSpacing = default(double);
this.ParseDeviceInfo(aDeviceInfo, out columns, out columnSpacing);
this.ValidateFields(columns, columnSpacing);
this.m_dynamicImageDpiX = this.m_dpiX;
this.m_dynamicImageDpiY = this.m_dpiY;
}
public static Bookmarks GetBookmarksStream(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, int page)
{
int page2 = 0;
Stream interactivityChunck = InteractivityChunks.GetInteractivityChunck(report, "Bookmarks", page, out page2);
if (interactivityChunck != null)
{
return(new Bookmarks(interactivityChunck, page2));
}
return(null);
}
public override void WriteCustomNonSharedItemProps(RPLElementProps nonSharedProps, PageContext pageContext)
{
AspNetCore.ReportingServices.OnDemandReportRendering.Report report = ((AspNetCore.ReportingServices.OnDemandReportRendering.SubReport)base.m_source).Report;
if (report != null)
{
string reportLanguage = Report.GetReportLanguage(report);
if (reportLanguage != null)
{
((RPLSubReportProps)nonSharedProps).Language = reportLanguage;
}
}
}
public override void WriteCustomNonSharedItemProps(BinaryWriter spbifWriter, PageContext pageContext)
{
AspNetCore.ReportingServices.OnDemandReportRendering.Report report = ((AspNetCore.ReportingServices.OnDemandReportRendering.SubReport)base.m_source).Report;
if (report != null)
{
string reportLanguage = Report.GetReportLanguage(report);
if (reportLanguage != null)
{
spbifWriter.Write((byte)11);
spbifWriter.Write(reportLanguage);
}
}
}
public int ProcessFindStringEvent(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, int totalPages, int startPage, int endPage, string findValue)
{
if (findValue != null && startPage > 0 && endPage > 0)
{
int num = 0;
using (SPBProcessing sPBProcessing = new SPBProcessing(report, totalPages, true))
{
sPBProcessing.CanTracePagination = true;
sPBProcessing.SetContext(new SPBContext(0, 0, false));
return(sPBProcessing.FindString(startPage, endPage, findValue));
}
}
return(0);
}
public int ProcessUserSortEvent(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, string textbox, ref int numberOfPages, ref PaginationMode paginationMode)
{
if (textbox == null)
{
return(0);
}
int num = 0;
using (SPBProcessing sPBProcessing = new SPBProcessing(report, 0, false))
{
sPBProcessing.CanTracePagination = true;
sPBProcessing.SetContext(new SPBContext(0, 0, true));
return(sPBProcessing.FindUserSort(textbox, ref numberOfPages, ref paginationMode));
}
}
private void VisitSubReport(AspNetCore.ReportingServices.OnDemandReportRendering.SubReport subreportDef)
{
if (subreportDef.Report != null && subreportDef.Instance != null && !subreportDef.ProcessedWithError)
{
AspNetCore.ReportingServices.OnDemandReportRendering.Report report = subreportDef.Report;
if (!report.HasDocumentMap && !this.m_createSnapshot)
{
return;
}
foreach (AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection reportSection in report.ReportSections)
{
this.Visit(reportSection.Body.ReportItemCollection);
this.VisitStyle(reportSection.Body.Style);
}
}
}
public string ProcessDrillthroughEvent(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, int totalPages, string drillthroughId, out NameValueCollection parameters)
{
parameters = null;
if (drillthroughId == null)
{
return(null);
}
int lastPageCollected = 0;
string text = null;
using (SPBProcessing sPBProcessing = new SPBProcessing(report, totalPages, true))
{
sPBProcessing.CanTracePagination = true;
sPBProcessing.SetContext(new SPBContext(0, 0, true));
return(sPBProcessing.FindDrillthrough(drillthroughId, lastPageCollected, out parameters));
}
}
private static ReportItem FindReportItem(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, IEnumerable <string> reportItemPathSteps, out AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection reportSection)
{
reportSection = null;
int num = reportItemPathSteps.Count();
if (num == 0)
{
return(null);
}
bool flag = num > 1;
string text = reportItemPathSteps.FirstOrDefault();
ReportItem reportItem = null;
foreach (AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection reportSection2 in report.ReportSections)
{
foreach (ReportItem item in reportSection2.Body.ReportItemCollection)
{
if (flag)
{
AspNetCore.ReportingServices.OnDemandReportRendering.SubReport subReport = item as AspNetCore.ReportingServices.OnDemandReportRendering.SubReport;
if (subReport != null && subReport.Report != null && string.CompareOrdinal(item.Name, text) == 0)
{
reportItem = SelectiveRendering.FindReportItem(subReport.Report, reportItemPathSteps.Skip(1), out reportSection);
}
}
else
{
AspNetCore.ReportingServices.OnDemandReportRendering.Rectangle rectangle = item as AspNetCore.ReportingServices.OnDemandReportRendering.Rectangle;
if (rectangle != null)
{
reportItem = SelectiveRendering.FindReportItem(rectangle, text);
}
else if (string.CompareOrdinal(item.Name, text) == 0)
{
reportItem = item;
}
}
if (reportItem != null)
{
reportSection = reportSection2;
return(reportItem);
}
}
}
return(null);
}
public override void WriteCustomNonSharedItemProps(RPLElementProps nonSharedProps, RPLWriter rplWriter, PageContext pageContext)
{
AspNetCore.ReportingServices.OnDemandReportRendering.Report report = ((AspNetCore.ReportingServices.OnDemandReportRendering.SubReport)base.m_source).Report;
if (report != null && report.Language != null)
{
string text = null;
if (report.Language.IsExpression)
{
ReportInstance instance = report.Instance;
text = instance.Language;
}
else
{
text = report.Language.Value;
}
((RPLSubReportProps)nonSharedProps).Language = text;
}
}
private void Init(AspNetCore.ReportingServices.OnDemandReportRendering.Report report)
{
Page page = ((ReportElementCollectionBase <AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection>)report.ReportSections)[0].Page;
this.PageHeightStr = page.PageHeight.ToString();
this.PageWidthStr = page.PageWidth.ToString();
this.MarginTop = page.TopMargin.ToMillimeters();
this.MarginLeft = page.LeftMargin.ToMillimeters();
this.MarginBottom = page.BottomMargin.ToMillimeters();
this.MarginRight = page.RightMargin.ToMillimeters();
int count = report.ReportSections.Count;
this.m_sectionPaginationSettings = new SectionPaginationSettings[count];
for (int i = 0; i < count; i++)
{
this.m_sectionPaginationSettings[i] = new SectionPaginationSettings(((ReportElementCollectionBase <AspNetCore.ReportingServices.OnDemandReportRendering.ReportSection>)report.ReportSections)[i]);
}
}
public static string GetReportLanguage(AspNetCore.ReportingServices.OnDemandReportRendering.Report report)
{
string result = null;
ReportStringProperty language = report.Language;
if (language != null)
{
if (language.IsExpression)
{
ReportInstance instance = report.Instance;
result = instance.Language;
}
else
{
result = language.Value;
}
}
return(result);
}
public static int FindBoomark(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, string bookmarkId, ref string uniqueName, ref int lastPageCollected, ref bool reportDone)
{
int result = 0;
string text = null;
Stream chunk = report.GetChunk(AspNetCore.ReportingServices.OnDemandReportRendering.Report.ChunkTypes.Interactivity, "Bookmarks");
if (chunk != null && chunk.Length > 0)
{
chunk.Position = 0L;
BinaryReader binaryReader = new BinaryReader(chunk);
byte b = binaryReader.ReadByte();
while (true)
{
switch (b)
{
case 0:
break;
case 2:
lastPageCollected = binaryReader.ReadInt32();
reportDone = binaryReader.ReadBoolean();
goto IL_0090;
default:
goto IL_0090;
}
text = binaryReader.ReadString();
if (SPBProcessing.CompareWithOrdinalComparison(bookmarkId, text, false) == 0)
{
uniqueName = binaryReader.ReadString();
return(binaryReader.ReadInt32());
}
binaryReader.ReadString();
binaryReader.ReadInt32();
binaryReader.ReadByte();
b = binaryReader.ReadByte();
}
}
goto IL_0090;
IL_0090:
return(result);
}
public bool Render(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
try
{
this.ParseDeviceInfo(ref deviceInfo);
this.Render(report, deviceInfo, renderProperties, createAndRegisterStream);
return(true);
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, true);
}
}
public ReportPaginationInfo(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, Version serverRPLVersion, double pageHeight)
{
bool flag = false;
this.m_stream = report.GetOrCreateChunk(AspNetCore.ReportingServices.OnDemandReportRendering.Report.ChunkTypes.Pagination, "PaginationInfo", out flag);
if (this.m_stream != null)
{
if (flag)
{
this.m_version = serverRPLVersion;
this.m_pageHeight = pageHeight;
this.SavePaginationInfo();
this.m_paginatedPages = 0;
this.m_metadataPages = new List <long>();
this.m_reportDone = false;
}
else if (this.ExtractPaginationInfo(serverRPLVersion))
{
this.m_stream.Close();
this.m_stream = report.CreateChunk(AspNetCore.ReportingServices.OnDemandReportRendering.Report.ChunkTypes.Pagination, "PaginationInfo");
this.m_version = serverRPLVersion;
this.m_pageHeight = pageHeight;
this.SavePaginationInfo();
this.m_paginatedPages = 0;
this.m_metadataPages = new List <long>();
this.m_reportDone = false;
}
else if (pageHeight != this.m_pageHeight)
{
this.m_stream = null;
this.m_version = new Version(0, 0, 0);
this.m_paginatedPages = -1;
this.m_offsetLastPage = -1L;
this.m_offsetHeader = -1L;
this.m_pageHeight = 0.0;
this.m_metadataPages = null;
this.m_reportDone = false;
}
}
}
public override void WriteCustomNonSharedItemProps(BinaryWriter spbifWriter, RPLWriter rplWriter, PageContext pageContext)
{
AspNetCore.ReportingServices.OnDemandReportRendering.Report report = ((AspNetCore.ReportingServices.OnDemandReportRendering.SubReport)base.m_source).Report;
if (report != null && report.Language != null)
{
string text = null;
if (report.Language.IsExpression)
{
ReportInstance instance = report.Instance;
text = instance.Language;
}
else
{
text = report.Language.Value;
}
if (text != null)
{
spbifWriter.Write((byte)11);
spbifWriter.Write(text);
}
}
}
public bool RenderStream(string streamName, AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
try
{
if (string.IsNullOrEmpty(streamName))
{
return(false);
}
return(SPBProcessing.SPBProcessing.RenderSecondaryStream(report, createAndRegisterStream, streamName));
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, true);
}
}
public bool Render(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable someProps, CreateAndRegisterStream createAndRegisterStream)
{
double pageHeight = 1.7976931348623157E+308;
using (SPBProcessing.SPBProcessing sPBProcessing = new SPBProcessing.SPBProcessing(report, createAndRegisterStream, pageHeight))
{
DeviceInfo deviceInfo2 = new DeviceInfo(deviceInfo);
SPBContext sPBContext = new SPBContext();
sPBContext.StartPage = 0;
sPBContext.EndPage = 0;
sPBContext.MeasureItems = false;
sPBContext.AddSecondaryStreamNames = true;
sPBContext.AddToggledItems = deviceInfo2.ExpandToggles;
sPBContext.AddFirstPageHeaderFooter = true;
sPBProcessing.SetContext(sPBContext);
using (IWordWriter writer = this.NewWordWriter())
{
WordRenderer wordRenderer = this.NewWordRenderer(createAndRegisterStream, deviceInfo2, sPBProcessing, writer, report.Name);
try
{
return(wordRenderer.Render());
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, true);
}
}
}
}
public Report(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, PageContext pageContext, string rplVersion, bool defaultVersion)
{
this.m_report = report;
this.m_pageContext = pageContext;
if (!string.IsNullOrEmpty(rplVersion))
{
char[] separator = new char[1]
{
'.'
};
string[] array = rplVersion.Split(separator);
if (array.Length < 2)
{
this.m_rplVersion = new Version(10, 3, 0);
}
else
{
int major = SPBProcessing.ParseInt(array[0], 10);
int minor = SPBProcessing.ParseInt(array[1], 3);
int build = 0;
if (array.Length > 2)
{
build = SPBProcessing.ParseInt(array[2], 0);
}
this.m_rplVersion = new Version(major, minor, build);
}
}
else if (defaultVersion)
{
this.m_rplVersion = new Version(10, 3, 0);
}
else
{
this.m_rplVersion = new Version(10, 6, 0);
}
this.m_pageContext.VersionPicker = RPLReader.CompareRPLVersions(this.m_rplVersion);
}
private static Stream GetInteractivityChunck(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, string chunkName, int page, out int lastPage)
{
lastPage = 0;
Stream stream = null;
bool flag = false;
stream = ((page != 1) ? report.GetChunk(AspNetCore.ReportingServices.OnDemandReportRendering.Report.ChunkTypes.Interactivity, chunkName) : report.GetOrCreateChunk(AspNetCore.ReportingServices.OnDemandReportRendering.Report.ChunkTypes.Interactivity, chunkName, out flag));
if (stream == null)
{
return(null);
}
if (!flag)
{
long num = stream.Length - 9;
if (num > 0)
{
stream.Seek(num, SeekOrigin.Begin);
BinaryReader binaryReader = new BinaryReader(stream);
binaryReader.ReadByte();
num = 9 + binaryReader.ReadInt64();
stream.Seek(-num, SeekOrigin.End);
binaryReader.ReadByte();
lastPage = binaryReader.ReadInt32();
if (binaryReader.ReadBoolean())
{
return(null);
}
stream.Seek(-num, SeekOrigin.End);
}
else
{
stream.Seek(0L, SeekOrigin.Begin);
}
}
return(stream);
}
public PaginationSettings(AspNetCore.ReportingServices.OnDemandReportRendering.Report report)
{
this.Init(report);
this.ValidateFields(0, -1.0);
}
protected override bool InvokeRenderer(IRenderingExtension renderer, AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
return(renderer.RenderStream(this.m_streamName, report, reportServerParameters, deviceInfo, clientCapabilities, ref renderProperties, createAndRegisterStream));
}
public bool Render(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
try
{
this.ParseDeviceinfo(deviceInfo);
Stream output = this.CreateFinalOutputStream(report.Name, createAndRegisterStream);
MainEngine mainEngine = new MainEngine(createAndRegisterStream, this);
if (report.HasDocumentMap && !this.m_omitDocumentMap)
{
this.m_addedDocMap = mainEngine.AddDocumentMap(report.DocumentMap);
if (this.m_addedDocMap)
{
mainEngine.NextPage();
}
}
using (AspNetCore.ReportingServices.Rendering.SPBProcessing.SPBProcessing sPBProcessing = new AspNetCore.ReportingServices.Rendering.SPBProcessing.SPBProcessing(report, createAndRegisterStream, 1.7976931348623157E+308))
{
SPBContext sPBContext = new SPBContext();
sPBContext.StartPage = 0;
sPBContext.EndPage = 0;
sPBContext.MeasureItems = false;
sPBContext.AddSecondaryStreamNames = true;
sPBContext.AddToggledItems = true;
sPBContext.AddOriginalValue = true;
sPBProcessing.SetContext(sPBContext);
RPLReport rPLReport = null;
bool flag = true;
while (!sPBProcessing.Done)
{
sPBProcessing.GetNextPage(out rPLReport);
if (rPLReport != null)
{
if (flag)
{
flag = false;
if (sPBProcessing.Done)
{
mainEngine.AdjustFirstWorksheetName(report.Name, this.m_addedDocMap);
}
}
else
{
mainEngine.NextPage();
}
mainEngine.RenderRPLPage(rPLReport, !this.m_simplePageHeaders, this.m_suppressOutlines);
rPLReport.Release();
rPLReport = null;
}
}
mainEngine.Save(output);
}
if (report.JobContext != null)
{
IJobContext jobContext = report.JobContext;
lock (jobContext.SyncRoot)
{
if (jobContext.AdditionalInfo.ScalabilityTime == null)
{
jobContext.AdditionalInfo.ScalabilityTime = new ScaleTimeCategory();
}
jobContext.AdditionalInfo.ScalabilityTime.Rendering = mainEngine.TotalScaleTimeMs;
if (jobContext.AdditionalInfo.EstimatedMemoryUsageKB == null)
{
jobContext.AdditionalInfo.EstimatedMemoryUsageKB = new EstimatedMemoryUsageKBCategory();
}
jobContext.AdditionalInfo.EstimatedMemoryUsageKB.Rendering = mainEngine.PeakMemoryUsageKB;
}
}
mainEngine.Dispose();
return(false);
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, true);
}
}
protected override void Render(AspNetCore.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection deviceInfo, Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
PaginationSettings paginationSettings = new PaginationSettings(report, deviceInfo);
string text = paginationSettings.OutputFormat.ToString().ToUpperInvariant();
bool flag = true;
if (text == "TIFF")
{
text = "TIF";
flag = false;
}
else if (text == "EMFPLUS")
{
text = "EMF";
}
if (text == "EMF")
{
paginationSettings.DynamicImageDpiX = 96;
paginationSettings.DynamicImageDpiY = 96;
paginationSettings.DpiX = this.m_printDpiX;
paginationSettings.DpiY = this.m_printDpiY;
int measureImageDpiX = default(int);
int measureImageDpiY = default(int);
ImageWriter.GetScreenDpi(out measureImageDpiX, out measureImageDpiY);
paginationSettings.MeasureImageDpiX = measureImageDpiX;
paginationSettings.MeasureImageDpiY = measureImageDpiY;
}
else
{
paginationSettings.MeasureImageDpiX = paginationSettings.DpiX;
paginationSettings.MeasureImageDpiY = paginationSettings.DpiY;
}
paginationSettings.MeasureTextDpi = paginationSettings.DpiX;
Stream stream = default(Stream);
using (HPBProcessing.HPBProcessing hPBProcessing = new HPBProcessing.HPBProcessing(report, paginationSettings, createAndRegisterStream, ref renderProperties))
{
hPBProcessing.SetContext(hPBProcessing.PaginationSettings.StartPage, hPBProcessing.PaginationSettings.EndPage);
using (Renderer renderer = new Renderer(true))
{
stream = createAndRegisterStream(report.Name + (flag ? ('_' + hPBProcessing.PaginationSettings.StartPage.ToString(CultureInfo.InvariantCulture)) : ""), text, null, "image/" + text, !flag, StreamOper.CreateAndRegister);
using (ImageWriter imageWriter = new ImageWriter(renderer, stream, false, createAndRegisterStream, paginationSettings.MeasureImageDpiX, paginationSettings.MeasureImageDpiY))
{
imageWriter.OutputFormat = hPBProcessing.PaginationSettings.OutputFormat;
hPBProcessing.PaginationSettings.UseGenericDefault = !imageWriter.IsEmf;
imageWriter.BeginReport(hPBProcessing.PaginationSettings.DpiX, hPBProcessing.PaginationSettings.DpiY);
int num = hPBProcessing.PaginationSettings.StartPage;
while (true)
{
RPLReport rPLReport = default(RPLReport);
hPBProcessing.GetNextPage(out rPLReport);
if (rPLReport == null)
{
break;
}
if (flag && num > hPBProcessing.PaginationSettings.StartPage)
{
stream = (imageWriter.OutputStream = createAndRegisterStream(report.Name + '_' + num, text, null, "image/" + text, !flag, StreamOper.CreateForPersistedStreams));
}
renderer.ProcessPage(rPLReport, num, hPBProcessing.SharedFontCache, hPBProcessing.GlyphCache);
rPLReport.Release();
rPLReport = null;
num++;
}
imageWriter.EndReport();
}
}
}
stream.Flush();
}
