public void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, int ownerUniqueName, int index)
{
if (this.m_drillthroughReportName != null)
{
Global.Tracer.Assert(this.m_drillthroughReportName.Type == ExpressionInfo.Types.Constant);
if (this.m_drillthroughReportName.Value != null)
{
DrillthroughParameters drillthroughParameters = null;
if (this.m_drillthroughParameters != null)
{
ParameterValue parameterValue = null;
for (int i = 0; i < this.m_drillthroughParameters.Count; i++)
{
parameterValue = this.m_drillthroughParameters[i];
if (parameterValue.Omit != null)
{
Global.Tracer.Assert(parameterValue.Omit.Type == ExpressionInfo.Types.Constant);
if (!parameterValue.Omit.BoolValue)
{
goto IL_007c;
}
continue;
}
goto IL_007c;
IL_007c:
Global.Tracer.Assert(parameterValue.Value.Type == ExpressionInfo.Types.Constant);
if (drillthroughParameters == null)
{
drillthroughParameters = new DrillthroughParameters();
}
drillthroughParameters.Add(parameterValue.Name, parameterValue.Value.Value);
}
}
DrillthroughInformation drillthroughInfo = new DrillthroughInformation(this.m_drillthroughReportName.Value, drillthroughParameters, null);
string drillthroughId = ownerUniqueName.ToString(CultureInfo.InvariantCulture) + ":" + index.ToString(CultureInfo.InvariantCulture);
processingContext.DrillthroughInfo.AddDrillthrough(drillthroughId, drillthroughInfo);
}
}
}
public ActionItemInstance(ReportProcessing.ProcessingContext pc, ActionItem actionItemDef)
{
ParameterValueList drillthroughParameters = actionItemDef.DrillthroughParameters;
if (drillthroughParameters != null)
{
this.m_drillthroughParametersValues = new object[drillthroughParameters.Count];
this.m_drillthroughParametersOmits = new BoolList(drillthroughParameters.Count);
this.m_dataSetTokenIDs = new IntList(drillthroughParameters.Count);
for (int i = 0; i < drillthroughParameters.Count; i++)
{
if (drillthroughParameters[i].Value != null && drillthroughParameters[i].Value.Type == ExpressionInfo.Types.Token)
{
this.m_dataSetTokenIDs.Add(drillthroughParameters[i].Value.IntValue);
}
else
{
this.m_dataSetTokenIDs.Add(-1);
}
}
}
}
public static NonComputedUniqueNames[] CreateNonComputedUniqueNames(ReportProcessing.ProcessingContext pc, ReportItemCollection reportItemsDef)
{
if (reportItemsDef != null && pc != null)
{
ReportItemList nonComputedReportItems = reportItemsDef.NonComputedReportItems;
if (nonComputedReportItems == null)
{
return(null);
}
if (nonComputedReportItems.Count == 0)
{
return(null);
}
NonComputedUniqueNames[] array = new NonComputedUniqueNames[nonComputedReportItems.Count];
for (int i = 0; i < nonComputedReportItems.Count; i++)
{
array[i] = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, nonComputedReportItems[i]);
}
return(array);
}
return(null);
}
internal MatrixInstanceInfo(ReportProcessing.ProcessingContext pc, Matrix reportItemDef, MatrixInstance owner)
: base(pc, reportItemDef, owner, addToChunk: false)
{
if (0 < reportItemDef.CornerReportItems.Count && !reportItemDef.CornerReportItems.IsReportItemComputed(0))
{
m_cornerNonComputedNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItemDef.CornerReportItems[0]);
}
reportItemDef.CornerNonComputedUniqueNames = m_cornerNonComputedNames;
if (!pc.DelayAddingInstanceInfo)
{
if (reportItemDef.FirstInstance)
{
pc.ChunkManager.AddInstanceToFirstPage(this, owner, pc.InPageSection);
reportItemDef.FirstInstance = false;
}
else
{
pc.ChunkManager.AddInstance(this, owner, pc.InPageSection);
}
}
m_noRows = pc.ReportRuntime.EvaluateDataRegionNoRowsExpression(reportItemDef, reportItemDef.ObjectType, reportItemDef.Name, "NoRows");
}
public MatrixInstance(ReportProcessing.ProcessingContext pc, Matrix reportItemDef)
: base(pc.CreateUniqueName(), reportItemDef)
{
base.m_instanceInfo = new MatrixInstanceInfo(pc, reportItemDef, this);
pc.Pagination.EnterIgnoreHeight(reportItemDef.StartHidden);
this.m_columnInstances = new MatrixHeadingInstanceList();
this.m_rowInstances = new MatrixHeadingInstanceList();
this.m_cells = new MatrixCellInstancesList();
this.m_renderingPages = new RenderingPagesRangesList();
reportItemDef.CurrentPage = reportItemDef.StartPage;
this.m_startPage = reportItemDef.StartPage;
if (reportItemDef.FirstCellInstances == null)
{
int count = reportItemDef.CellReportItems.Count;
reportItemDef.FirstCellInstances = new BoolList(count);
for (int i = 0; i < count; i++)
{
reportItemDef.FirstCellInstances.Add(true);
}
}
this.m_inFirstPage = pc.ChunkManager.InFirstPage;
}
public ChartHeadingInstanceInfo(ReportProcessing.ProcessingContext pc, int headingCellIndex, ChartHeading chartHeadingDef, int labelIndex, VariantList groupExpressionValues)
{
this.m_headingCellIndex = headingCellIndex;
if (chartHeadingDef.ChartGroupExpression)
{
if (groupExpressionValues == null || DBNull.Value == ((ArrayList)groupExpressionValues)[0])
{
this.m_groupExpressionValue = null;
}
else
{
this.m_groupExpressionValue = ((ArrayList)groupExpressionValues)[0];
}
}
if (chartHeadingDef.Labels != null)
{
ExpressionInfo expressionInfo = chartHeadingDef.Labels[labelIndex];
if (expressionInfo != null)
{
if (chartHeadingDef.Grouping != null)
{
this.m_headingLabel = pc.ReportRuntime.EvaluateChartDynamicHeadingLabelExpression(chartHeadingDef, expressionInfo, chartHeadingDef.DataRegionDef.Name);
}
else
{
this.m_headingLabel = pc.ReportRuntime.EvaluateChartStaticHeadingLabelExpression(chartHeadingDef, expressionInfo, chartHeadingDef.DataRegionDef.Name);
}
}
}
if (chartHeadingDef.Grouping == null)
{
this.m_staticGroupingIndex = labelIndex;
}
else if (chartHeadingDef.Grouping.CustomProperties != null)
{
this.m_customPropertyInstances = chartHeadingDef.Grouping.CustomProperties.EvaluateExpressions(chartHeadingDef.DataRegionDef.ObjectType, chartHeadingDef.DataRegionDef.Name, chartHeadingDef.Grouping.Name + ".", pc);
}
}
private string EvaluateConnectStringExpression(ReportProcessing.ProcessingContext processingContext)
{
if (this.m_connectString == null)
{
return(null);
}
if (ExpressionInfo.Types.Constant == this.m_connectString.Type)
{
return(this.m_connectString.Value);
}
Global.Tracer.Assert(null != processingContext.ReportRuntime);
if (processingContext.ReportRuntime.ReportExprHost != null)
{
this.SetExprHost(processingContext.ReportRuntime.ReportExprHost, processingContext.ReportObjectModel);
}
StringResult stringResult = processingContext.ReportRuntime.EvaluateConnectString(this);
if (stringResult.ErrorOccurred)
{
throw new ReportProcessingException(ErrorCode.rsDataSourceConnectStringProcessingError, this.m_name);
}
return(stringResult.Value);
}
public MatrixHeadingInstance(ReportProcessing.ProcessingContext pc, int headingCellIndex, MatrixHeading matrixHeadingDef, bool isSubtotal, int reportItemDefIndex, VariantList groupExpressionValues, out NonComputedUniqueNames nonComputedUniqueNames)
{
this.m_uniqueName = pc.CreateUniqueName();
if (isSubtotal && matrixHeadingDef.Subtotal.StyleClass != null)
{
base.m_instanceInfo = new MatrixSubtotalHeadingInstanceInfo(pc, headingCellIndex, matrixHeadingDef, this, isSubtotal, reportItemDefIndex, groupExpressionValues, out nonComputedUniqueNames);
if (matrixHeadingDef.GetInnerStaticHeading() != null)
{
this.m_subHeadingInstances = new MatrixHeadingInstanceList();
}
}
else
{
base.m_instanceInfo = new MatrixHeadingInstanceInfo(pc, headingCellIndex, matrixHeadingDef, this, isSubtotal, reportItemDefIndex, groupExpressionValues, out nonComputedUniqueNames);
if (matrixHeadingDef.SubHeading != null)
{
this.m_subHeadingInstances = new MatrixHeadingInstanceList();
}
}
this.m_renderingPages = new RenderingPagesRangesList();
this.m_matrixHeadingDef = matrixHeadingDef;
this.m_isSubtotal = isSubtotal;
this.m_headingDefIndex = reportItemDefIndex;
if (!matrixHeadingDef.IsColumn)
{
pc.Pagination.EnterIgnoreHeight(matrixHeadingDef.StartHidden);
}
if (matrixHeadingDef.FirstHeadingInstances == null)
{
int count = matrixHeadingDef.ReportItems.Count;
matrixHeadingDef.FirstHeadingInstances = new BoolList(count);
for (int i = 0; i < count; i++)
{
matrixHeadingDef.FirstHeadingInstances.Add(true);
}
}
}
public CustomReportItemCellInstance AddCell(ReportProcessing.ProcessingContext pc)
{
CustomReportItem customReportItem = (CustomReportItem)base.m_reportItemDef;
bool flag = customReportItem.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column;
int rowIndex;
int colIndex;
if (flag)
{
rowIndex = this.m_currentOuterStaticIndex;
colIndex = this.m_currentInnerStaticIndex;
}
else
{
colIndex = this.m_currentOuterStaticIndex;
rowIndex = this.m_currentInnerStaticIndex;
}
CustomReportItemCellInstance customReportItemCellInstance = new CustomReportItemCellInstance(rowIndex, colIndex, customReportItem, pc);
if (flag)
{
this.m_cells[this.m_currentCellOuterIndex].Add(customReportItemCellInstance);
}
else
{
if (this.m_currentCellOuterIndex == 0)
{
Global.Tracer.Assert(this.m_cells.Count == this.m_currentCellInnerIndex);
CustomReportItemCellInstanceList value = new CustomReportItemCellInstanceList();
this.m_cells.Add(value);
}
this.m_cells[this.m_currentCellInnerIndex].Add(customReportItemCellInstance);
}
this.m_currentCellInnerIndex++;
return(customReportItemCellInstance);
}
internal TableGroupInstance(ReportProcessing.ProcessingContext pc, TableGroup tableGroupDef)
{
Table table = (Table)tableGroupDef.DataRegionDef;
m_uniqueName = pc.CreateUniqueName();
m_instanceInfo = new TableGroupInstanceInfo(pc, tableGroupDef, this);
pc.Pagination.EnterIgnoreHeight(tableGroupDef.StartHidden);
m_tableGroupDef = tableGroupDef;
IndexedExprHost visibilityHiddenExprHost = (tableGroupDef.ExprHost != null) ? tableGroupDef.ExprHost.TableRowVisibilityHiddenExpressions : null;
m_renderingPages = new RenderingPagesRangesList();
if (tableGroupDef.HeaderRows != null)
{
m_headerRowInstances = new TableRowInstance[tableGroupDef.HeaderRows.Count];
for (int i = 0; i < m_headerRowInstances.Length; i++)
{
m_headerRowInstances[i] = new TableRowInstance(pc, tableGroupDef.HeaderRows[i], table, visibilityHiddenExprHost);
}
}
if (tableGroupDef.FooterRows != null)
{
m_footerRowInstances = new TableRowInstance[tableGroupDef.FooterRows.Count];
for (int j = 0; j < m_footerRowInstances.Length; j++)
{
m_footerRowInstances[j] = new TableRowInstance(pc, tableGroupDef.FooterRows[j], table, visibilityHiddenExprHost);
}
}
if (tableGroupDef.SubGroup != null)
{
m_subGroupInstances = new TableGroupInstanceList();
}
else if (table.TableDetail != null)
{
m_tableDetailInstances = new TableDetailInstanceList();
}
}
public ChartDataPointInstance AddCell(ReportProcessing.ProcessingContext pc, int currCellDPIndex)
{
ChartDataPointInstancesList dataPoints = this.CurrentMultiChart.DataPoints;
Chart chart = (Chart)base.m_reportItemDef;
int num = (currCellDPIndex < 0) ? this.GetCurrentCellDPIndex() : currCellDPIndex;
ChartDataPointInstance chartDataPointInstance = new ChartDataPointInstance(pc, chart, this.GetCellDataPoint(num), num);
if (chart.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column)
{
dataPoints[this.m_currentCellOuterIndex].Add(chartDataPointInstance);
}
else
{
if (this.m_currentCellOuterIndex == 0)
{
Global.Tracer.Assert(dataPoints.Count == this.m_currentCellInnerIndex);
ChartDataPointInstanceList value = new ChartDataPointInstanceList();
dataPoints.Add(value);
}
dataPoints[this.m_currentCellInnerIndex].Add(chartDataPointInstance);
}
this.m_currentCellInnerIndex++;
return(chartDataPointInstance);
}
internal CustomReportItemCellInstance AddCell(ReportProcessing.ProcessingContext pc)
{
CustomReportItem customReportItem = (CustomReportItem)m_reportItemDef;
bool num = customReportItem.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column;
int rowIndex;
int colIndex;
if (num)
{
rowIndex = m_currentOuterStaticIndex;
colIndex = m_currentInnerStaticIndex;
}
else
{
colIndex = m_currentOuterStaticIndex;
rowIndex = m_currentInnerStaticIndex;
}
CustomReportItemCellInstance customReportItemCellInstance = new CustomReportItemCellInstance(rowIndex, colIndex, customReportItem, pc);
if (num)
{
m_cells[m_currentCellOuterIndex].Add(customReportItemCellInstance);
}
else
{
if (m_currentCellOuterIndex == 0)
{
Global.Tracer.Assert(m_cells.Count == m_currentCellInnerIndex);
CustomReportItemCellInstanceList value = new CustomReportItemCellInstanceList();
m_cells.Add(value);
}
m_cells[m_currentCellInnerIndex].Add(customReportItemCellInstance);
}
m_currentCellInnerIndex++;
return(customReportItemCellInstance);
}
public void SetCellAggregateRowInfo(int headingLevel, ReportProcessing.ProcessingContext pc)
{
Global.Tracer.Assert(this.m_outerGroupingAggregateRowInfo != null && null != this.m_pivotAggregateRowInfo);
this.m_pivotAggregateRowInfo.CombineAggregateInfo(pc, this.m_outerGroupingAggregateRowInfo[headingLevel]);
}
public CheckBoxInstanceInfo(ReportProcessing.ProcessingContext pc, CheckBox reportItemDef, ReportItemInstance owner, int index)
: base(pc, reportItemDef, owner, index)
{
}
public ImageInstanceInfo(ReportProcessing.ProcessingContext pc, Image reportItemDef, ReportItemInstance owner, int index, bool customCreated)
: base(pc, reportItemDef, owner, index, customCreated)
{
}
internal SubReportInstanceInfo(ReportProcessing.ProcessingContext pc, SubReport reportItemDef, SubReportInstance owner, int index)
: base(pc, reportItemDef, owner, index)
{
m_noRows = pc.ReportRuntime.EvaluateSubReportNoRowsExpression(reportItemDef, reportItemDef.Name, "NoRows");
}
internal SubReportInstance(ReportProcessing.ProcessingContext pc, SubReport reportItemDef, int index)
: base(pc.CreateUniqueName(), reportItemDef)
{
m_instanceInfo = new SubReportInstanceInfo(pc, reportItemDef, this, index);
pc.Pagination.EnterIgnoreHeight(reportItemDef.StartHidden);
}
public RectangleInstanceInfo(ReportProcessing.ProcessingContext pc, Rectangle reportItemDef, RectangleInstance owner, int index)
: base(pc, reportItemDef, owner, index)
{
}
internal void MatchEventSource(TextBox textBox, TextBoxInstance textBoxInstance, ReportProcessing.IScope containingScope, ReportProcessing.ProcessingContext processingContext)
{
bool flag = false;
if (!(containingScope is ReportProcessing.RuntimePivotCell))
{
while (containingScope != null && !(containingScope is ReportProcessing.RuntimeGroupLeafObj) && !(containingScope is ReportProcessing.RuntimeDetailObj) && !(containingScope is ReportProcessing.RuntimeOnePassDetailObj))
{
containingScope = containingScope.GetOuterScope(includeSubReportContainingScope: true);
}
}
if (containingScope == null)
{
if (m_eventSource.ContainingScopes == null || m_eventSource.ContainingScopes.Count == 0)
{
flag = true;
}
}
else if (m_eventSourceScope == containingScope)
{
flag = true;
DataRegion dataRegion = null;
if (containingScope is ReportProcessing.RuntimeDetailObj)
{
dataRegion = ((ReportProcessing.RuntimeDetailObj)containingScope).DataRegionDef;
}
else if (containingScope is ReportProcessing.RuntimeOnePassDetailObj)
{
dataRegion = ((ReportProcessing.RuntimeOnePassDetailObj)containingScope).DataRegionDef;
}
if (dataRegion != null && dataRegion.CurrentDetailRowIndex != m_eventSourceDetailIndex)
{
flag = false;
}
}
if (flag)
{
if (textBox == m_eventSource)
{
m_newUniqueName = textBoxInstance.UniqueName;
m_page = processingContext.Pagination.GetTextBoxStartPage(textBox);
}
else if (m_peerSortFilters != null && m_peerSortFilters.Contains(textBox.ID))
{
m_peerSortFilters[textBox.ID] = textBoxInstance.UniqueName;
}
}
}
internal ListInstanceInfo(ReportProcessing.ProcessingContext pc, List reportItemDef, ListInstance owner)
: base(pc, reportItemDef, owner, addToChunk: true)
{
m_noRows = pc.ReportRuntime.EvaluateDataRegionNoRowsExpression(reportItemDef, reportItemDef.ObjectType, reportItemDef.Name, "NoRows");
}
public LineInstance(ReportProcessing.ProcessingContext pc, Line reportItemDef, int index)
: base(pc.CreateUniqueName(), reportItemDef)
{
base.m_instanceInfo = new LineInstanceInfo(pc, reportItemDef, this, index);
}
internal PageSectionInstanceInfo(ReportProcessing.ProcessingContext pc, PageSection reportItemDef, PageSectionInstance owner)
: base(pc, reportItemDef, owner, addToChunk: true)
{
}
void IShowHideContainer.BeginProcessContainer(ReportProcessing.ProcessingContext context)
{
context.BeginProcessContainer(m_uniqueName, m_tableGroupDef.Visibility);
}
void IShowHideReceiver.ProcessReceiver(ReportProcessing.ProcessingContext context, int uniqueName)
{
this.m_startHidden = context.ProcessReceiver(uniqueName, this.m_reportItemDef.Visibility, this.m_reportItemDef.ExprHost, this.m_reportItemDef.ObjectType, this.m_reportItemDef.Name);
}
void IShowHideContainer.EndProcessContainer(ReportProcessing.ProcessingContext context)
{
context.EndProcessContainer(m_uniqueName, m_listDef.Visibility);
}
void IShowHideSender.ProcessSender(ReportProcessing.ProcessingContext context, int uniqueName)
{
this.m_initialToggleState = context.ProcessSender(uniqueName, base.m_startHidden, (TextBox)base.m_reportItemDef);
}
internal ChartTitleInstance(ReportProcessing.ProcessingContext pc, Chart chart, ChartTitle titleDef, string propertyName)
{
m_uniqueName = pc.CreateUniqueName();
m_caption = pc.ReportRuntime.EvaluateChartTitleCaptionExpression(titleDef, chart.Name, propertyName);
m_styleAttributeValues = Chart.CreateStyle(pc, titleDef.StyleClass, chart.Name + "." + propertyName, m_uniqueName);
}
public CustomReportItemInstanceInfo(ReportProcessing.ProcessingContext pc, CustomReportItem reportItemDef, CustomReportItemInstance owner)
: base(pc, reportItemDef, owner, true)
{
}
internal ActionInstance(ReportProcessing.ProcessingContext pc)
{
m_uniqueName = pc.CreateUniqueName();
}
void IShowHideContainer.EndProcessContainer(ReportProcessing.ProcessingContext context)
{
context.EndProcessContainer(this.m_uniqueName, this.m_tableGroupDef.Visibility);
}
