internal static bool ValidateProcessingRestrictions(CustomReportItemHeadingList headings, bool isColumn, bool hasStatic, InitializationContext context)
{
bool flag = true;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
string propertyName = isColumn ? "column" : "row";
if (headings != null)
{
for (int i = 0; i < headings.Count; i++)
{
CustomReportItemHeading customReportItemHeading = headings[i];
if (!customReportItemHeading.Static && customReportItemHeading.Grouping == null)
{
context.ErrorContext.Register(ProcessingErrorCode.rsInvalidGrouping, Severity.Error, context.ObjectType, context.ObjectName, propertyName);
flag = false;
}
if (customReportItemHeading.Subtotal)
{
context.ErrorContext.Register(ProcessingErrorCode.rsCRISubtotalNotSupported, Severity.Error, context.ObjectType, context.ObjectName, propertyName);
flag = false;
}
if (customReportItemHeading.Static && hasStatic)
{
flag3 = true;
}
if (customReportItemHeading.Static && customReportItemHeading.InnerHeadings != null)
{
flag4 = true;
}
if (!customReportItemHeading.Static && headings.Count > 1)
{
flag2 = true;
}
if (flag && !flag2 && !flag3 && !flag4 && customReportItemHeading.InnerHeadings != null && !ValidateProcessingRestrictions(customReportItemHeading.InnerHeadings, isColumn, customReportItemHeading.Static, context))
{
flag = false;
}
}
}
if (flag3)
{
context.ErrorContext.Register(ProcessingErrorCode.rsCRIMultiStaticColumnsOrRows, Severity.Error, context.ObjectType, context.ObjectName, propertyName);
flag = false;
}
if (flag4)
{
context.ErrorContext.Register(ProcessingErrorCode.rsCRIStaticWithSubgroups, Severity.Error, context.ObjectType, context.ObjectName, propertyName);
flag = false;
}
if (flag2)
{
context.ErrorContext.Register(ProcessingErrorCode.rsCRIMultiNonStaticGroups, Severity.Error, context.ObjectType, context.ObjectName, propertyName);
flag = false;
}
return(flag);
}
internal void CopySubHeadingAggregates()
{
if (m_innerHeadings != null)
{
int count = m_innerHeadings.Count;
for (int i = 0; i < count; i++)
{
CustomReportItemHeading customReportItemHeading = m_innerHeadings[i];
customReportItemHeading.CopySubHeadingAggregates();
Tablix.CopyAggregates(customReportItemHeading.Aggregates, m_aggregates);
Tablix.CopyAggregates(customReportItemHeading.PostSortAggregates, m_postSortAggregates);
Tablix.CopyAggregates(customReportItemHeading.RecursiveAggregates, m_aggregates);
}
}
}
private static CustomReportItemHeading HeadingClone(CustomReportItemHeading heading, DataCellsList dataRowCells, ref int currentIndex, int headingSpan, InitializationContext context)
{
Global.Tracer.Assert(heading != null);
CustomReportItemHeading customReportItemHeading = new CustomReportItemHeading(context.GenerateSubtotalID(), (CustomReportItem)heading.DataRegionDef);
customReportItemHeading.m_isColumn = heading.m_isColumn;
customReportItemHeading.m_level = heading.m_level;
customReportItemHeading.m_static = true;
customReportItemHeading.m_subtotal = false;
customReportItemHeading.m_headingSpan = heading.m_headingSpan;
if (heading.m_customProperties != null)
{
customReportItemHeading.m_customProperties = heading.m_customProperties.DeepClone(context);
}
if (heading.m_innerHeadings == null)
{
if (heading.m_isColumn)
{
int count = dataRowCells.Count;
for (int i = 0; i < count; i++)
{
DataCellList dataCellList = dataRowCells[i];
Global.Tracer.Assert(currentIndex + headingSpan <= dataCellList.Count);
dataCellList.Insert(currentIndex + headingSpan, dataCellList[currentIndex].DeepClone(context));
}
}
else
{
Global.Tracer.Assert(currentIndex + headingSpan <= dataRowCells.Count);
DataCellList dataCellList2 = dataRowCells[currentIndex];
int count2 = dataCellList2.Count;
DataCellList dataCellList3 = new DataCellList(count2);
dataRowCells.Insert(currentIndex + headingSpan, dataCellList3);
for (int j = 0; j < count2; j++)
{
dataCellList3.Add(dataCellList2[j].DeepClone(context));
}
}
currentIndex++;
}
return(customReportItemHeading);
}
internal bool Initialize(int level, CustomReportItemHeadingList peerHeadings, int headingIndex, DataCellsList dataRowCells, ref int currentIndex, ref int maxLevel, InitializationContext context)
{
m_level = level;
if (level > maxLevel)
{
maxLevel = level;
}
context.ExprHostBuilder.DataGroupingStart(m_isColumn);
if (m_static)
{
Global.Tracer.Assert(!m_subtotal);
if (m_grouping != null)
{
context.ErrorContext.Register(ProcessingErrorCode.rsInvalidStaticDataGrouping, Severity.Error, context.ObjectType, context.ObjectName, "DataGrouping");
m_grouping = null;
}
else
{
m_sorting = null;
CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
}
}
else
{
if ((context.Location & LocationFlags.InDetail) != 0)
{
context.ErrorContext.Register(ProcessingErrorCode.rsInvalidDetailDataGrouping, Severity.Error, context.ObjectType, context.ObjectName, "DataGrouping");
return(false);
}
if (m_grouping != null && m_grouping.CustomProperties != null)
{
if (m_customProperties == null)
{
m_customProperties = new DataValueList(m_grouping.CustomProperties.Count);
}
m_customProperties.AddRange(m_grouping.CustomProperties);
m_grouping.CustomProperties = null;
}
if (m_subtotal)
{
if (m_grouping != null)
{
context.AggregateRewriteScopes = new Hashtable();
context.AggregateRewriteScopes.Add(m_grouping.Name, null);
}
Global.Tracer.Assert(peerHeadings[headingIndex] != null);
int currentIndex2 = currentIndex;
CustomReportItemHeading customReportItemHeading = HeadingClone(this, dataRowCells, ref currentIndex2, m_headingSpan, context);
customReportItemHeading.m_innerHeadings = HeadingListClone(m_innerHeadings, dataRowCells, ref currentIndex2, m_headingSpan, context);
Global.Tracer.Assert(currentIndex + m_headingSpan == currentIndex2);
Global.Tracer.Assert(!customReportItemHeading.m_subtotal && m_subtotal);
Global.Tracer.Assert(headingIndex < peerHeadings.Count);
peerHeadings.Insert(headingIndex + 1, customReportItemHeading);
context.AggregateRewriteScopes = null;
context.AggregateRewriteMap = null;
}
if (m_grouping != null)
{
context.Location |= LocationFlags.InGrouping;
context.RegisterGroupingScope(m_grouping.Name, m_grouping.SimpleGroupExpressions, m_grouping.Aggregates, m_grouping.PostSortAggregates, m_grouping.RecursiveAggregates, m_grouping);
ObjectType objectType = context.ObjectType;
string objectName = context.ObjectName;
context.ObjectType = ObjectType.Grouping;
context.ObjectName = m_grouping.Name;
CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
context.ObjectType = objectType;
context.ObjectName = objectName;
context.UnRegisterGroupingScope(m_grouping.Name);
}
else
{
context.Location |= LocationFlags.InDetail;
CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
}
}
m_exprHostID = context.ExprHostBuilder.DataGroupingEnd(m_isColumn);
m_hasExprHost |= (m_exprHostID >= 0);
return(m_subtotal);
}
internal CustomReportItemHeadingInstance(ReportProcessing.ProcessingContext pc, int headingCellIndex, CustomReportItemHeading headingDef, VariantList groupExpressionValues, int recursiveLevel)
{
if (headingDef.InnerHeadings != null)
{
m_subHeadingInstances = new CustomReportItemHeadingInstanceList();
}
m_headingDef = headingDef;
m_headingCellIndex = headingCellIndex;
if (groupExpressionValues != null)
{
m_groupExpressionValues = new VariantList(groupExpressionValues.Count);
for (int i = 0; i < groupExpressionValues.Count; i++)
{
if (groupExpressionValues[i] == null || DBNull.Value == groupExpressionValues[i])
{
m_groupExpressionValues.Add(null);
}
else
{
m_groupExpressionValues.Add(groupExpressionValues[i]);
}
}
}
if (headingDef.Grouping != null && headingDef.Grouping.GroupLabel != null)
{
m_label = pc.NavigationInfo.RegisterLabel(pc.ReportRuntime.EvaluateGroupingLabelExpression(headingDef.Grouping, headingDef.DataRegionDef.ObjectType, headingDef.DataRegionDef.Name));
}
if (headingDef.CustomProperties != null)
{
m_customPropertyInstances = headingDef.CustomProperties.EvaluateExpressions(headingDef.DataRegionDef.ObjectType, headingDef.DataRegionDef.Name, "DataGrouping.", pc);
}
m_recursiveLevel = recursiveLevel;
}
