internal PageContextCommon(PaginationSettings pagination, AddTextBoxDelegate aAddTextBoxDelegate, bool consumeWhitespace, CreateAndRegisterStream createAndRegisterStream)
{
m_pagination = pagination;
m_addTextBox = aAddTextBoxDelegate;
m_consumeWhitespace = consumeWhitespace;
m_createAndRegisterStream = createAndRegisterStream;
}
public Interactivity(string itemInfo, EventType eventType, string streamName, CreateAndRegisterStream createAndRegisterStream)
{
this.m_itemInfo = itemInfo;
this.m_eventType = eventType;
this.m_streamName = streamName;
this.m_createAndRegisterStream = createAndRegisterStream;
}
public void RenderReportHTML(string deviceInfo, PageCountMode pageCountMode, CreateAndRegisterStream createStreamCallback, out string scrollScript, out string pageStyle)
{
var di = ReportingServices.Diagnostics.RSRequestParameters.ShallowXmlToNameValueCollection(deviceInfo, "DeviceInfo");
var info = Html.HTMLRenderer.CreateDeviceInfo(1, "", "", "", "", false, false);
LocalHtmlRenderer.Render(CombineDeviceInfo(info, di), pageCountMode, this, createStreamCallback, out scrollScript, out pageStyle);
}
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;
}
}
}
private void InitCache(CreateAndRegisterStream streamDelegate)
{
if (this._scalabilityCache == null)
{
this._scalabilityCache = (ScalabilityCache)ScalabilityUtils.CreateCacheForTransientAllocations(streamDelegate, "Word", AspNetCore.ReportingServices.Rendering.WordRenderer.WordOpenXmlRenderer.Models.StorageObjectCreator.Instance, WordRendererReferenceCreator.Instance, ComponentType.Rendering, 1);
}
}
internal Interactivity(string itemInfo, EventType eventType, string streamName, CreateAndRegisterStream createAndRegisterStream)
{
m_itemInfo = itemInfo;
m_eventType = eventType;
m_streamName = streamName;
m_createAndRegisterStream = createAndRegisterStream;
}
public void Init(CreateAndRegisterStream createAndRegisterStream, AutoFit autoFit, string reportName)
{
this.m_outStream = createAndRegisterStream(reportName, "doc", null, "application/msword", false, StreamOper.CreateAndRegister);
this.m_tableStream = createAndRegisterStream("TableStream", null, null, null, true, StreamOper.CreateOnly);
this.m_mainStream = createAndRegisterStream("WordDocument", null, null, null, true, StreamOper.CreateOnly);
this.m_fontTable = createAndRegisterStream("FontTable", null, null, null, true, StreamOper.CreateOnly);
this.m_dataStream = createAndRegisterStream("Data", null, null, null, true, StreamOper.CreateOnly);
this.m_listStream = createAndRegisterStream("List", null, null, null, true, StreamOper.CreateOnly);
this.m_listLevelStream = createAndRegisterStream("ListLevel", null, null, null, true, StreamOper.CreateOnly);
Stream textPiece = createAndRegisterStream("TextPiece", null, null, null, true, StreamOper.CreateOnly);
Stream chpTable = createAndRegisterStream("ChpTable", null, null, null, true, StreamOper.CreateOnly);
Stream papTable = createAndRegisterStream("PapTable", null, null, null, true, StreamOper.CreateOnly);
this.m_charFormat = new CharacterFormat(chpTable, this.m_fcStart);
this.m_parFormat = new ParagraphFormat(papTable, this.m_fcStart);
this.m_wordText = new WordText(textPiece);
this.m_secFormat = new SectionFormat();
this.m_currentRow = new TableData(1, true);
this.m_tapStack = new Stack <TableData>();
this.m_fontNameSet = new Dictionary <string, int>();
this.WriteFont("Times New Roman");
this.WriteFont("Symbol");
this.WriteFont("Arial");
this.m_imgIndex = 0;
this.m_fldsMain = new FieldsTable();
this.m_fldsHdr = new FieldsTable();
this.m_fldsCurrent = this.m_fldsMain;
this.m_bookmarks = new Bookmarks();
this.m_images = new Dictionary <ImageHash, int>();
this.m_autoFit = autoFit;
}
public ExecuteQueriesContext(IDbConnection connection, IProcessingDataExtensionConnection dataExtensionConnection, DataSourceInfo dataSourceInfo, CreateAndRegisterStream createAndRegisterStream, IJobContext jobContext)
{
this.m_connection = connection;
this.m_dataExtensionConnection = dataExtensionConnection;
this.m_dataSourceInfo = dataSourceInfo;
this.m_createAndRegisterStream = createAndRegisterStream;
this.m_jobContext = jobContext;
}
public static IScalabilityCache CreateCacheForTransientAllocations(CreateAndRegisterStream createStreamCallback, string streamNamePrefix, IScalabilityObjectCreator objectCreator, IReferenceCreator referenceCreator, ComponentType componentType, int minReservedMemoryMB)
{
int rifCompatVersion = 0;
ISpaceManager spaceManager = new PromoteLocalitySpaceManager(52428800L);
IStorage storage = new RIFStorage(new CreateAndRegisterStreamHandler(streamNamePrefix + "_Data", createStreamCallback), 4096, 200, 500, spaceManager, objectCreator, referenceCreator, null, false, rifCompatVersion);
IIndexStrategy indexStrategy = new IndexTable(new CreateAndRegisterStreamHandler(streamNamePrefix + "_Index", createStreamCallback), 1024, 100);
return(new ScalabilityCache(storage, indexStrategy, componentType, minReservedMemoryMB * 1048576));
}
public void Init(CreateAndRegisterStream createAndRegisterStream, AutoFit autoFit, string reportName)
{
this._createAndRegisterStream = createAndRegisterStream;
this._autofit = autoFit;
this.InitCache(this._createAndRegisterStream);
this._document = new OpenXmlDocumentModel(createAndRegisterStream(reportName, "docx", null, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", true, StreamOper.CreateAndRegister), this.CreateXmlStreamImplementation, this._scalabilityCache);
this._nextPictureId = 0u;
this._forceEmptyLayoutCell = false;
}
protected WriterBase(Renderer renderer, Stream stream, bool disposeRenderer, CreateAndRegisterStream createAndRegisterStream)
{
this.m_renderer = renderer;
this.m_outputStream = stream;
this.m_disposeRenderer = disposeRenderer;
this.m_createAndRegisterStream = createAndRegisterStream;
if (this.m_renderer != null)
{
this.m_renderer.Writer = this;
}
}
internal PageContextCommon(string pageName, double pageHeight, bool registerEvents, bool consumeWhitespace, CreateAndRegisterStream createAndRegisterStream)
{
m_pageHeight = pageHeight;
m_originalPageHeight = pageHeight;
m_registerEvents = registerEvents;
m_consumeWhitespace = consumeWhitespace;
m_sharedItemSizes = new Hashtable();
m_sharedEdgeItemSizes = new Hashtable();
m_sharedRenderItemSizes = new Hashtable();
m_sharedRenderEdgeItemSizes = new Hashtable();
m_sharedRenderRepeatItemSizes = new Hashtable();
m_registeredStreamNames = new Hashtable();
m_registeredPBIgnored = new Hashtable();
m_createAndRegisterStream = createAndRegisterStream;
m_pageTotalInfo = new PageTotalInfo(pageName);
}
public void GetRenderingResource(CreateAndRegisterStream createAndRegisterStreamCallback, NameValueCollection deviceInfo)
{
try
{
ROMReport.GetRenderingResource(createAndRegisterStreamCallback, deviceInfo["GetImage"]);
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, unexpected: true);
}
}
/// <summary>
/// 开始执行异步打印
/// </summary>
/// <param name="format"></param>
/// <param name="allowInternalRenderers"></param>
/// <param name="deviceInfo"></param>
/// <param name="pageCountMode"></param>
/// <param name="createStreamCallback"></param>
/// <param name="onCompleteCallback"></param>
/// <param name="isPartialRendering"></param>
private void BeginAsyncRender(string format,
bool allowInternalRenderers,
string deviceInfo,
CreateAndRegisterStream createStreamCallback,
AsyncCompletedEventHandler onCompleteCallback,
bool isPartialRendering)
{
object postRenderArgs = Activator.CreateInstance(_postRenderArgsType, false, isPartialRendering);
object operation = Activator.CreateInstance(
_asyncAllStreamsRenderingOperationType,
this._report, format, deviceInfo,
allowInternalRenderers,
postRenderArgs,
createStreamCallback);
EventInfo eventInfo = _asyncAllStreamsRenderingOperationType.GetEvent("Completed");
eventInfo.AddEventHandler(operation, onCompleteCallback);
this._processingThread.BeginBackgroundOperation(operation);
}
public DataSetContext(string targetChunkNameInSnapshot, string cachedDataChunkName, bool mustCreateDataChunk, IRowConsumer consumerRequest, ICatalogItemContext itemContext, RuntimeDataSourceInfoCollection dataSources, string requestUserName, DateTime executionTimeStamp, ParameterInfoCollection parameters, IChunkFactory createChunkFactory, ReportProcessing.ExecutionType interactiveExecution, CultureInfo culture, UserProfileState allowUserProfileState, UserProfileState initialUserProfileState, IProcessingDataExtensionConnection createDataExtensionInstanceFunction, CreateAndRegisterStream createStreamCallbackForScalability, ReportRuntimeSetup dataSetRuntimeSetup, IJobContext jobContext, IDataProtection dataProtection)
{
m_targetChunkNameInSnapshot = targetChunkNameInSnapshot;
m_cachedDataChunkName = cachedDataChunkName;
m_mustCreateDataChunk = mustCreateDataChunk;
m_consumerRequest = consumerRequest;
m_itemContext = itemContext;
m_dataSources = dataSources;
m_requestUserName = requestUserName;
m_executionTimeStamp = executionTimeStamp;
m_parameters = parameters;
m_createChunkFactory = createChunkFactory;
m_interactiveExecution = interactiveExecution;
m_culture = culture;
m_allowUserProfileState = allowUserProfileState;
m_initialUserProfileState = initialUserProfileState;
m_createDataExtensionInstanceFunction = createDataExtensionInstanceFunction;
m_createStreamCallbackForScalability = createStreamCallbackForScalability;
m_dataSetRuntimeSetup = dataSetRuntimeSetup;
m_jobContext = jobContext;
m_dataProtection = dataProtection;
}
internal ProcessingContext(ICatalogItemContext reportContext, string requestUserName, ParameterInfoCollection parameters, ReportProcessing.OnDemandSubReportCallback subReportCallback, IGetResource getResourceFunction, IChunkFactory createChunkFactory, ReportProcessing.ExecutionType interactiveExecution, CultureInfo culture, UserProfileState allowUserProfileState, UserProfileState initialUserProfileState, ReportRuntimeSetup reportRuntimeSetup, CreateAndRegisterStream createStreamCallback, bool isHistorySnapshot, IJobContext jobContext, IExtensionFactory extFactory, IDataProtection dataProtection)
{
Global.Tracer.Assert(reportContext != null, "(null != reportContext)");
m_reportContext = reportContext;
m_requestUserName = requestUserName;
m_parameters = parameters;
m_queryParameters = m_parameters.GetQueryParameters();
m_subReportCallback = subReportCallback;
m_getResourceFunction = getResourceFunction;
m_chunkFactory = createChunkFactory;
m_interactiveExecution = interactiveExecution;
m_userLanguage = culture;
m_allowUserProfileState = allowUserProfileState;
m_initialUserProfileState = initialUserProfileState;
m_reportRuntimeSetup = reportRuntimeSetup;
m_createStreamCallback = createStreamCallback;
m_isHistorySnapshot = isHistorySnapshot;
ChunkFactoryAdapter @object = new ChunkFactoryAdapter(m_chunkFactory);
m_createReportChunkCallback = @object.CreateReportChunk;
m_jobContext = jobContext;
m_extFactory = extFactory;
m_dataProtection = dataProtection;
}
public static void GetRenderingResource(CreateAndRegisterStream createAndRegisterStreamCallback, string imageName)
{
if (imageName == null)
{
return;
}
imageName = imageName.TrimStart('/');
string text = ParseFromUrl(imageName);
if (text == null)
{
return;
}
string mimeType = "";
using (Stream stream = HTMLRendererResources.GetStream(text, out mimeType))
{
if (stream != null)
{
Stream sink = createAndRegisterStreamCallback(text, "gif", null, mimeType, willSeek: false, StreamOper.CreateAndRegister);
Utility.CopyStream(stream, sink);
}
}
}
internal void InternalRender(string format, bool allowInternalRenderers, string deviceInfo, PageCountMode pageCountMode, CreateAndRegisterStream createStreamCallback, out Warning[] warnings)
{
lock (m_syncObject)
{
if (createStreamCallback == null)
{
throw new ArgumentNullException("createStreamCallback");
}
if (!ValidateRenderingFormat(format))
{
throw new ArgumentOutOfRangeException("format");
}
EnsureExecutionSession();
try
{
m_lastRenderingWarnings = m_processingHost.Render(format, deviceInfo, PageCountModeToProcessingPaginationMode(pageCountMode), allowInternalRenderers, m_dataSources, createStreamCallback.ToOuterType());
}
catch (Exception processingException)
{
throw WrapProcessingException(processingException);
}
warnings = Warning.FromProcessingMessageList(m_lastRenderingWarnings);
WriteDebugResults(warnings);
}
}
public bool RenderStream(string streamName, Microsoft.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
return(false);
}
public bool Render(Microsoft.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection reportServerParameters, NameValueCollection deviceInfo, NameValueCollection clientCapabilities, ref Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
try
{
ParseDeviceInfo(ref deviceInfo);
Render(report, deviceInfo, renderProperties, createAndRegisterStream);
return(true);
}
catch (ReportRenderingException)
{
throw;
}
catch (Exception ex2)
{
if (AsynchronousExceptionDetection.IsStoppingException(ex2))
{
throw;
}
throw new ReportRenderingException(ex2, unexpected: true);
}
}
protected virtual void Render(Microsoft.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection deviceInfo, Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
}
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();
}
internal WordOpenXmlRenderer(CreateAndRegisterStream createAndRegisterStream, Microsoft.ReportingServices.Rendering.SPBProcessing.SPBProcessing spbProcessing, IWordWriter writer, DeviceInfo deviceInfo, string reportName)
: base(createAndRegisterStream, spbProcessing, writer, deviceInfo, reportName)
{
}
protected override void Render(Microsoft.ReportingServices.OnDemandReportRendering.Report report, NameValueCollection deviceInfo, Hashtable renderProperties, CreateAndRegisterStream createAndRegisterStream)
{
PaginationSettings paginationSettings = new PaginationSettings(report, deviceInfo);
paginationSettings.UseEmSquare = true;
paginationSettings.MeasureTextDpi = 1000;
paginationSettings.UseGenericDefault = false;
if (paginationSettings.DynamicImageDpiX == 96)
{
paginationSettings.DynamicImageDpiX = 300;
}
if (paginationSettings.DynamicImageDpiY == 96)
{
paginationSettings.DynamicImageDpiY = 300;
}
BufferedStream bufferedStream;
using (Microsoft.ReportingServices.Rendering.HPBProcessing.HPBProcessing hPBProcessing = new Microsoft.ReportingServices.Rendering.HPBProcessing.HPBProcessing(report, paginationSettings, createAndRegisterStream, ref renderProperties))
{
hPBProcessing.SetContext(hPBProcessing.PaginationSettings.StartPage, hPBProcessing.PaginationSettings.EndPage);
using (Renderer renderer = new Renderer(physicalPagination: true))
{
bufferedStream = new BufferedStream(createAndRegisterStream(report.Name, "pdf", null, "application/pdf", willSeek: false, StreamOper.CreateAndRegister));
using (PDFWriter pDFWriter = new PDFWriter(renderer, bufferedStream, disposeRenderer: false, createAndRegisterStream, hPBProcessing.PaginationSettings.DpiX, hPBProcessing.PaginationSettings.DpiY))
{
pDFWriter.HumanReadablePDF = m_humanReadablePDF;
pDFWriter.PrintOnOpen = m_printOnOpen;
pDFWriter.Test = m_test;
pDFWriter.EmbedFonts = m_embedFonts;
if (report.HasDocumentMap)
{
DocumentMap documentMap = null;
try
{
documentMap = report.DocumentMap;
if (documentMap != null)
{
if (documentMap.MoveNext())
{
DocumentMapNode current = documentMap.Current;
HandleDocumentMap(documentMap, pDFWriter.DocumentMapRootLabel = new PDFLabel(current.Id, current.Label), 1);
}
if (pDFWriter.DocumentMapRootLabel.Children == null || pDFWriter.DocumentMapRootLabel.Children.Count == 0)
{
pDFWriter.DocumentMapRootLabel = null;
}
else
{
pDFWriter.DocumentMapLabelPoints = new Dictionary <string, PDFPagePoint>();
}
}
}
finally
{
documentMap?.Dispose();
}
}
int num = hPBProcessing.PaginationSettings.StartPage;
pDFWriter.BeginReport(hPBProcessing.PaginationSettings.MeasureTextDpi, hPBProcessing.PaginationSettings.MeasureTextDpi);
while (true)
{
hPBProcessing.GetNextPage(out RPLReport rplReport);
if (rplReport == null)
{
break;
}
renderer.ProcessPage(rplReport, num, hPBProcessing.SharedFontCache, hPBProcessing.GlyphCache);
rplReport.Release();
rplReport = null;
num++;
}
pDFWriter.EndReport();
}
}
}
bufferedStream.Flush();
}
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));
}
protected override WordRenderer NewWordRenderer(CreateAndRegisterStream createAndRegisterStream, DeviceInfo deviceInfoObj, Microsoft.ReportingServices.Rendering.SPBProcessing.SPBProcessing spbProcessing, IWordWriter writer, string reportName)
{
return(new Word97Renderer(createAndRegisterStream, spbProcessing, writer, deviceInfoObj, reportName));
}
public ProcessingStreamHandler(CreateAndRegisterStream createStreamCallback)
{
this.m_allowOnlyTemporaryStreams = false;
this.m_createStreamCallback = createStreamCallback;
}
public Html5ServerRenderer(ROMReport report, Microsoft.ReportingServices.Rendering.SPBProcessing.SPBProcessing spbProcessing, NameValueCollection reportServerParams, DeviceInfo deviceInfo, NameValueCollection rawDeviceInfo, NameValueCollection browserCaps, CreateAndRegisterStream createAndRegisterStreamCallback, SecondaryStreams secondaryStreams)
: base(report, spbProcessing, reportServerParams, deviceInfo, rawDeviceInfo, browserCaps, createAndRegisterStreamCallback, secondaryStreams)
{
}
public void GetRenderingResource(CreateAndRegisterStream createAndRegisterStreamCallback, NameValueCollection deviceInfo)
{
}
public HPBProcessing(Microsoft.ReportingServices.OnDemandReportRendering.Report report, PaginationSettings pagination, CreateAndRegisterStream createAndRegisterStream, ref Hashtable renderProperties)
{
Init(report, pagination, createAndRegisterStream, ref renderProperties);
}
