private void CalculateColumns(MatrixHeading column, double width)
{
if (column != null)
{
double num = width;
if (column.Grouping == null)
{
if (column.ReportItems != null)
{
for (int i = 0; i < column.ReportItems.Count; i++)
{
this.CalculateSize(column.ReportItems[i], this.m_columns[i].WidthValue, column.SizeValue);
if (this.m_columns[i].WidthValue < num)
{
num = this.m_columns[i].WidthValue;
}
}
}
}
else
{
if (column.Subtotal != null)
{
this.CalculateSize(column.Subtotal.ReportItem, width, column.SizeValue);
}
this.CalculateSize(column.ReportItem, width, column.SizeValue);
}
this.CalculateColumns(column.SubHeading, num);
}
}
private void CalculateRows(MatrixHeading row, double height)
{
if (row != null)
{
double num = height;
if (row.Grouping == null)
{
if (row.ReportItems != null)
{
for (int i = 0; i < row.ReportItems.Count; i++)
{
this.CalculateSize(row.ReportItems[i], row.SizeValue, this.m_rows[i].HeightValue);
if (this.m_rows[i].HeightValue < num)
{
num = this.m_rows[i].HeightValue;
}
}
}
}
else
{
if (row.Subtotal != null)
{
this.CalculateSize(row.Subtotal.ReportItem, row.SizeValue, height);
}
this.CalculateSize(row.ReportItem, row.SizeValue, height);
}
this.CalculateRows(row.SubHeading, num);
}
}
public static void Calculate(Matrix matrix)
{
Global.Tracer.Assert(null != matrix);
OWCFlagsCalculator oWCFlagsCalculator = new OWCFlagsCalculator();
oWCFlagsCalculator.CalculateOWCFlags(matrix);
if (oWCFlagsCalculator.m_useOWC)
{
matrix.UseOWC = oWCFlagsCalculator.m_useOWC;
matrix.OwcCellNames = oWCFlagsCalculator.m_owcCellNames;
int num = 0;
for (MatrixHeading matrixHeading = matrix.Rows; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
if (matrixHeading.Grouping != null)
{
matrixHeading.OwcGroupExpression = oWCFlagsCalculator.m_owcGroupExpression[num];
num++;
}
}
for (MatrixHeading matrixHeading2 = matrix.Columns; matrixHeading2 != null; matrixHeading2 = matrixHeading2.SubHeading)
{
if (matrixHeading2.Grouping != null)
{
matrixHeading2.OwcGroupExpression = oWCFlagsCalculator.m_owcGroupExpression[num];
num++;
}
}
}
}
public void Add(MatrixHeadingInstance matrixHeadingInstance, ReportProcessing.ProcessingContext pc)
{
if (this.m_lastHeadingInstance != null)
{
this.m_lastHeadingInstance.InstanceInfo.HeadingSpan = matrixHeadingInstance.InstanceInfo.HeadingCellIndex - this.m_lastHeadingInstance.InstanceInfo.HeadingCellIndex;
bool flag = true;
MatrixHeading matrixHeadingDef = this.m_lastHeadingInstance.MatrixHeadingDef;
if (pc.ReportItemsReferenced)
{
Matrix matrix = (Matrix)matrixHeadingDef.DataRegionDef;
if (matrixHeadingDef.IsColumn)
{
if (matrix.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column)
{
flag = false;
}
}
else if (matrix.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Row)
{
flag = false;
}
}
if (flag)
{
bool flag2;
if (this.m_lastHeadingInstance.IsSubtotal)
{
flag2 = this.m_lastHeadingInstance.MatrixHeadingDef.Subtotal.FirstInstance;
this.m_lastHeadingInstance.MatrixHeadingDef.Subtotal.FirstInstance = false;
}
else
{
BoolList firstHeadingInstances = this.m_lastHeadingInstance.MatrixHeadingDef.FirstHeadingInstances;
flag2 = firstHeadingInstances[this.m_lastHeadingInstance.HeadingIndex];
firstHeadingInstances[this.m_lastHeadingInstance.HeadingIndex] = false;
}
pc.ChunkManager.AddInstance(this.m_lastHeadingInstance.InstanceInfo, this.m_lastHeadingInstance, flag2 || matrixHeadingDef.InFirstPage, pc.InPageSection);
}
}
base.Add(matrixHeadingInstance);
this.m_lastHeadingInstance = matrixHeadingInstance;
matrixHeadingInstance.MatrixHeadingDef.InFirstPage = pc.ChunkManager.InFirstPage;
}
private GroupingList GenerateUserSortGroupingList(bool rowIsInnerGrouping)
{
GroupingList groupingList = new GroupingList();
for (MatrixHeading matrixHeading = rowIsInnerGrouping ? this.m_rows : this.m_columns; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
if (matrixHeading.Grouping != null)
{
groupingList.Add(matrixHeading.Grouping);
}
}
for (MatrixHeading matrixHeading = rowIsInnerGrouping ? this.m_columns : this.m_rows; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
if (matrixHeading.Grouping != null)
{
groupingList.Add(matrixHeading.Grouping);
}
}
return(groupingList);
}
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 void CalculatePropagatedFlags()
{
MatrixHeading matrixHeading = this.m_rows;
int num = 0;
do
{
if (matrixHeading.Grouping != null)
{
if (matrixHeading.Grouping.PageBreakAtStart)
{
this.m_propagatedPageBreakAtStart = true;
this.m_innerRowLevelWithPageBreak = num;
}
if (matrixHeading.Grouping.PageBreakAtEnd)
{
this.m_propagatedPageBreakAtEnd = true;
this.m_innerRowLevelWithPageBreak = num;
}
}
matrixHeading = matrixHeading.SubHeading;
num++;
}while (matrixHeading != null);
}
public MatrixHeadingInstanceInfo(ReportProcessing.ProcessingContext pc, int headingCellIndex, MatrixHeading matrixHeadingDef, MatrixHeadingInstance owner, bool isSubtotal, int reportItemDefIndex, VariantList groupExpressionValues, out NonComputedUniqueNames nonComputedUniqueNames)
{
ReportItemCollection reportItems;
if (isSubtotal)
{
reportItems = matrixHeadingDef.Subtotal.ReportItems;
}
else
{
reportItems = matrixHeadingDef.ReportItems;
if (matrixHeadingDef.OwcGroupExpression)
{
if (groupExpressionValues == null || DBNull.Value == ((ArrayList)groupExpressionValues)[0])
{
this.m_groupExpressionValue = null;
}
else
{
this.m_groupExpressionValue = ((ArrayList)groupExpressionValues)[0];
}
}
}
if (0 < reportItems.Count && !reportItems.IsReportItemComputed(reportItemDefIndex))
{
this.m_contentUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItems[reportItemDefIndex]);
}
nonComputedUniqueNames = this.m_contentUniqueNames;
this.m_headingCellIndex = headingCellIndex;
if (!isSubtotal && pc.ShowHideType != 0)
{
this.m_startHidden = pc.ProcessReceiver(owner.UniqueName, matrixHeadingDef.Visibility, matrixHeadingDef.ExprHost, matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name);
}
if (matrixHeadingDef.Grouping != null && matrixHeadingDef.Grouping.GroupLabel != null)
{
this.m_label = pc.NavigationInfo.RegisterLabel(pc.ReportRuntime.EvaluateGroupingLabelExpression(matrixHeadingDef.Grouping, matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name));
}
if (matrixHeadingDef.Grouping != null && matrixHeadingDef.Grouping.CustomProperties != null)
{
this.m_customPropertyInstances = matrixHeadingDef.Grouping.CustomProperties.EvaluateExpressions(matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name, matrixHeadingDef.Grouping.Name + ".", pc);
}
matrixHeadingDef.StartHidden = this.m_startHidden;
}
public MatrixSubtotalHeadingInstanceInfo(ReportProcessing.ProcessingContext pc, int headingCellIndex, MatrixHeading matrixHeadingDef, MatrixHeadingInstance owner, bool isSubtotal, int reportItemDefIndex, VariantList groupExpressionValues, out NonComputedUniqueNames nonComputedUniqueNames)
: base(pc, headingCellIndex, matrixHeadingDef, owner, isSubtotal, reportItemDefIndex, groupExpressionValues, out nonComputedUniqueNames)
{
Global.Tracer.Assert(isSubtotal);
Global.Tracer.Assert(null != matrixHeadingDef.Subtotal);
Global.Tracer.Assert(null != matrixHeadingDef.Subtotal.StyleClass);
if (matrixHeadingDef.Subtotal.StyleClass.ExpressionList != null)
{
this.m_styleAttributeValues = new object[matrixHeadingDef.Subtotal.StyleClass.ExpressionList.Count];
ReportProcessing.RuntimeRICollection.EvaluateStyleAttributes(ObjectType.Subtotal, matrixHeadingDef.Grouping.Name, matrixHeadingDef.Subtotal.StyleClass, owner.UniqueName, this.m_styleAttributeValues, pc);
}
}
private void MatrixCellInitialize(InitializationContext context, int expectedNumberOfMatrixColumns, int expectedNumberOfMatrixRows, bool computedSubtotal, out double totalCellHeight, out double totalCellWidth)
{
if (expectedNumberOfMatrixColumns != this.m_matrixColumns.Count)
{
context.ErrorContext.Register(ProcessingErrorCode.rsWrongNumberOfMatrixColumns, Severity.Error, context.ObjectType, context.ObjectName, "MatrixColumns");
}
if (expectedNumberOfMatrixRows != this.m_matrixRows.Count)
{
context.ErrorContext.Register(ProcessingErrorCode.rsWrongNumberOfMatrixRows, Severity.Error, context.ObjectType, context.ObjectName, "MatrixRows");
}
for (int i = 0; i < this.m_matrixRows.Count; i++)
{
if (expectedNumberOfMatrixColumns != this.m_matrixRows[i].NumberOfMatrixCells)
{
context.ErrorContext.Register(ProcessingErrorCode.rsWrongNumberOfMatrixCells, Severity.Error, context.ObjectType, context.ObjectName, "MatrixCells");
}
}
totalCellHeight = 0.0;
totalCellWidth = 0.0;
for (int j = 0; j < this.m_matrixColumns.Count; j++)
{
this.m_matrixColumns[j].Initialize(context);
totalCellWidth = Math.Round(totalCellWidth + this.m_matrixColumns[j].WidthValue, Validator.DecimalPrecision);
}
for (int k = 0; k < this.m_matrixRows.Count; k++)
{
this.m_matrixRows[k].Initialize(context);
totalCellHeight = Math.Round(totalCellHeight + this.m_matrixRows[k].HeightValue, Validator.DecimalPrecision);
}
context.Location = (context.Location | LocationFlags.InMatrixCell | LocationFlags.InMatrixCellTopLevelItem);
context.MatrixName = base.m_name;
context.RegisterTablixCellScope(this.m_columns.SubHeading == null && null == this.m_columns.Grouping, base.m_cellAggregates, base.m_cellPostSortAggregates);
for (MatrixHeading matrixHeading = this.m_rows; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
context.RegisterReportItems(matrixHeading.ReportItems);
if (matrixHeading.Grouping != null)
{
context.Location |= LocationFlags.InGrouping;
context.RegisterGroupingScopeForTablixCell(matrixHeading.Grouping.Name, false, matrixHeading.Grouping.SimpleGroupExpressions, matrixHeading.Aggregates, matrixHeading.PostSortAggregates, matrixHeading.RecursiveAggregates, matrixHeading.Grouping);
}
}
if (this.m_rows.Grouping != null && this.m_rows.Subtotal != null && this.m_staticRows != null)
{
context.CopyRunningValues(this.StaticRows.ReportItems.RunningValues, base.m_aggregates);
}
for (MatrixHeading matrixHeading = this.m_columns; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
context.RegisterReportItems(matrixHeading.ReportItems);
if (matrixHeading.Grouping != null)
{
context.Location |= LocationFlags.InGrouping;
context.RegisterGroupingScopeForTablixCell(matrixHeading.Grouping.Name, true, matrixHeading.Grouping.SimpleGroupExpressions, matrixHeading.Aggregates, matrixHeading.PostSortAggregates, matrixHeading.RecursiveAggregates, matrixHeading.Grouping);
}
}
if (this.m_columns.Grouping != null && this.m_columns.Subtotal != null && this.m_staticColumns != null)
{
context.CopyRunningValues(this.StaticColumns.ReportItems.RunningValues, base.m_aggregates);
}
if (computedSubtotal)
{
this.m_cellReportItems.MarkChildrenComputed();
}
context.RegisterReportItems(this.m_cellReportItems);
OWCFlagsCalculator.Calculate(this);
bool registerHiddenReceiver = context.RegisterHiddenReceiver;
context.RegisterHiddenReceiver = false;
context.RegisterScopeInMatrixCell(base.Name, "0_CellScope" + base.Name, true);
this.m_cellReportItems.Initialize(context, true);
if (context.IsRunningValueDirectionColumn())
{
base.m_processingInnerGrouping = ProcessingInnerGroupings.Row;
}
context.UpdateScopesInMatrixCells(base.Name, this.GenerateUserSortGroupingList(ProcessingInnerGroupings.Row == base.m_processingInnerGrouping));
context.TextboxesWithDetailSortExpressionInitialize();
context.RegisterHiddenReceiver = registerHiddenReceiver;
for (MatrixHeading matrixHeading = this.m_rows; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
context.UnRegisterReportItems(matrixHeading.ReportItems);
if (matrixHeading.Grouping != null)
{
context.UnRegisterGroupingScopeForTablixCell(matrixHeading.Grouping.Name, false);
context.ProcessUserSortInnerScope(matrixHeading.Grouping.Name, true, false);
}
}
for (MatrixHeading matrixHeading = this.m_rows; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
if (matrixHeading.Grouping != null)
{
context.ValidateUserSortInnerScope(matrixHeading.Grouping.Name);
}
}
for (MatrixHeading matrixHeading = this.m_columns; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
context.UnRegisterReportItems(matrixHeading.ReportItems);
if (matrixHeading.Grouping != null)
{
context.UnRegisterGroupingScopeForTablixCell(matrixHeading.Grouping.Name, true);
context.ProcessUserSortInnerScope(matrixHeading.Grouping.Name, true, true);
}
}
for (MatrixHeading matrixHeading = this.m_columns; matrixHeading != null; matrixHeading = matrixHeading.SubHeading)
{
if (matrixHeading.Grouping != null)
{
context.ValidateUserSortInnerScope(matrixHeading.Grouping.Name);
}
}
this.m_cellReportItems.RegisterReceiver(context);
context.UnRegisterReportItems(this.m_cellReportItems);
context.UnRegisterTablixCellScope();
}
private void CalculateOWCFlags(MatrixHeading heading)
{
if (heading != null)
{
if (heading.Grouping == null)
{
this.m_staticHeadingCount++;
if (this.m_staticHeadingCount > 1)
{
this.m_useOWC = false;
return;
}
if (heading.SubHeading != null)
{
this.m_useOWC = false;
return;
}
if (heading.ReportItems != null)
{
int num = 0;
while (num < heading.ReportItems.Count)
{
this.DetectIllegalReportItems(heading.ReportItems[num]);
if (this.IsFinish())
{
return;
}
TextBox textBox = this.FindNotAlwaysHiddenTextBox(heading.ReportItems[num]);
if (this.IsFinish())
{
break;
}
if (textBox != null)
{
num++;
continue;
}
this.m_useOWC = false;
break;
}
}
goto IL_017d;
}
ExpressionInfo expressionInfo = null;
if (heading.Grouping.GroupExpressions != null)
{
if (heading.Grouping.GroupExpressions.Count != 1)
{
this.m_useOWC = false;
return;
}
expressionInfo = heading.Grouping.GroupExpressions[0];
}
this.DetectIllegalReportItems(heading.ReportItem);
if (!this.IsFinish())
{
TextBox textBox2 = this.FindNotAlwaysHiddenTextBox(heading.ReportItem);
if (!this.IsFinish())
{
if (textBox2 != null)
{
Global.Tracer.Assert(null != expressionInfo);
Global.Tracer.Assert(null != textBox2.Value);
if (expressionInfo.OriginalText != textBox2.Value.OriginalText)
{
this.m_owcGroupExpression.Add(true);
}
else
{
this.m_owcGroupExpression.Add(false);
}
goto IL_017d;
}
this.m_useOWC = false;
}
}
}
return;
IL_017d:
this.CalculateOWCFlags(heading.SubHeading);
}
