public PivotHeading(int id, DataRegion matrixDef)
: base(id, matrixDef)
{
this.m_aggregates = new DataAggregateInfoList();
this.m_postSortAggregates = new DataAggregateInfoList();
this.m_recursiveAggregates = new DataAggregateInfoList();
}
public TablixHeading(int id, DataRegion dataRegionDef)
: base(id, dataRegionDef)
{
this.m_aggregates = new DataAggregateInfoList();
this.m_postSortAggregates = new DataAggregateInfoList();
this.m_recursiveAggregates = new DataAggregateInfoList();
}
public int[] GetRepeatSiblings()
{
AspNetCore.ReportingServices.ReportProcessing.DataRegion dataRegion = (AspNetCore.ReportingServices.ReportProcessing.DataRegion)base.ReportItemDef;
if (dataRegion.RepeatSiblings == null)
{
return(new int[0]);
}
int[] array = new int[dataRegion.RepeatSiblings.Count];
dataRegion.RepeatSiblings.CopyTo(array);
return(array);
}
public 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(true);
}
}
if (containingScope == null)
{
if (this.m_eventSource.ContainingScopes == null || this.m_eventSource.ContainingScopes.Count == 0)
{
flag = true;
}
}
else if (this.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 != this.m_eventSourceDetailIndex)
{
flag = false;
}
}
if (flag)
{
if (textBox == this.m_eventSource)
{
this.m_newUniqueName = textBoxInstance.UniqueName;
this.m_page = processingContext.Pagination.GetTextBoxStartPage(textBox);
}
else if (this.m_peerSortFilters != null && this.m_peerSortFilters.Contains(textBox.ID))
{
this.m_peerSortFilters[textBox.ID] = textBoxInstance.UniqueName;
}
}
}
private InScopeSortFilterHashtable GetSortFiltersInScope(bool create, bool inDetail)
{
InScopeSortFilterHashtable inScopeSortFilterHashtable = null;
ReportItem parent = base.m_parent;
if (inDetail)
{
while (parent != null && !(parent is DataRegion))
{
parent = parent.Parent;
}
}
else
{
while (parent != null && !(parent is Report))
{
parent = parent.Parent;
}
}
Global.Tracer.Assert(parent is DataRegion || parent is Report);
if (parent is Report)
{
Report report = (Report)parent;
if (this.m_userSort.SortExpressionScope == null)
{
if (report.DetailSortFiltersInScope == null && create)
{
report.DetailSortFiltersInScope = new InScopeSortFilterHashtable();
}
return(report.DetailSortFiltersInScope);
}
if (report.NonDetailSortFiltersInScope == null && create)
{
report.NonDetailSortFiltersInScope = new InScopeSortFilterHashtable();
}
return(report.NonDetailSortFiltersInScope);
}
Global.Tracer.Assert(null == this.m_userSort.SortExpressionScope);
DataRegion dataRegion = (DataRegion)parent;
if (dataRegion.DetailSortFiltersInScope == null && create)
{
dataRegion.DetailSortFiltersInScope = new InScopeSortFilterHashtable();
}
return(dataRegion.DetailSortFiltersInScope);
}
public ReportHierarchyNode(int id, DataRegion dataRegionDef)
: base(id)
{
this.m_dataRegionDef = dataRegionDef;
}
public bool PopulateRuntimeSortFilterEventInfo(ReportProcessing.ProcessingContext pc, DataSet myDataSet)
{
if (pc.UserSortFilterInfo != null && pc.UserSortFilterInfo.SortInfo != null && pc.OldSortFilterEventInfo != null)
{
if (this.m_dataSetID != -1)
{
return(false);
}
this.m_runtimeSortFilterInfo = null;
EventInformation.SortEventInfo sortInfo = pc.UserSortFilterInfo.SortInfo;
for (int i = 0; i < sortInfo.Count; i++)
{
int uniqueNameAt = sortInfo.GetUniqueNameAt(i);
SortFilterEventInfo sortFilterEventInfo = pc.OldSortFilterEventInfo[uniqueNameAt];
if (sortFilterEventInfo != null && sortFilterEventInfo.EventSource.UserSort != null && sortFilterEventInfo.EventSource.UserSort.DataSetID == myDataSet.ID)
{
if (this.m_runtimeSortFilterInfo == null)
{
this.m_runtimeSortFilterInfo = new RuntimeSortFilterEventInfoList();
}
this.m_runtimeSortFilterInfo.Add(new RuntimeSortFilterEventInfo(sortFilterEventInfo.EventSource, uniqueNameAt, sortInfo.GetSortDirectionAt(i), sortFilterEventInfo.EventSourceScopeInfo));
}
}
if (this.m_runtimeSortFilterInfo != null)
{
int count = this.m_runtimeSortFilterInfo.Count;
for (int j = 0; j < count; j++)
{
TextBox eventSource = this.m_runtimeSortFilterInfo[j].EventSource;
ISortFilterScope sortExpressionScope = eventSource.UserSort.SortExpressionScope;
if (sortExpressionScope != null)
{
sortExpressionScope.IsSortFilterExpressionScope = this.SetSortFilterInfo(sortExpressionScope.IsSortFilterExpressionScope, count, j);
}
ISortFilterScope sortTarget = eventSource.UserSort.SortTarget;
if (sortTarget != null)
{
sortTarget.IsSortFilterTarget = this.SetSortFilterInfo(sortTarget.IsSortFilterTarget, count, j);
}
if (eventSource.ContainingScopes != null && 0 < eventSource.ContainingScopes.Count)
{
int num = 0;
for (int k = 0; k < eventSource.ContainingScopes.Count; k++)
{
Grouping grouping = eventSource.ContainingScopes[k];
VariantList variantList = this.m_runtimeSortFilterInfo[j].SortSourceScopeInfo[k];
if (grouping != null)
{
if (grouping.SortFilterScopeInfo == null)
{
grouping.SortFilterScopeInfo = new VariantList[count];
for (int l = 0; l < count; l++)
{
grouping.SortFilterScopeInfo[l] = null;
}
grouping.SortFilterScopeIndex = new int[count];
for (int m = 0; m < count; m++)
{
grouping.SortFilterScopeIndex[m] = -1;
}
}
grouping.SortFilterScopeInfo[j] = variantList;
grouping.SortFilterScopeIndex[j] = k;
}
else
{
SubReportList detailScopeSubReports = eventSource.UserSort.DetailScopeSubReports;
ReportItem parent;
if (detailScopeSubReports != null && num < detailScopeSubReports.Count)
{
parent = detailScopeSubReports[num++].Parent;
}
else
{
Global.Tracer.Assert(k == eventSource.ContainingScopes.Count - 1, "(j == eventSource.ContainingScopes.Count - 1)");
parent = eventSource.Parent;
}
while (parent != null && !(parent is DataRegion))
{
parent = parent.Parent;
}
Global.Tracer.Assert(parent is DataRegion, "(parent is DataRegion)");
DataRegion dataRegion = (DataRegion)parent;
if (dataRegion.SortFilterSourceDetailScopeInfo == null)
{
dataRegion.SortFilterSourceDetailScopeInfo = new int[count];
for (int n = 0; n < count; n++)
{
dataRegion.SortFilterSourceDetailScopeInfo[n] = -1;
}
}
Global.Tracer.Assert(variantList != null && 1 == variantList.Count, "(null != scopeValues && 1 == scopeValues.Count)");
dataRegion.SortFilterSourceDetailScopeInfo[j] = (int)((ArrayList)variantList)[0];
}
}
}
GroupingList groupsInSortTarget = eventSource.UserSort.GroupsInSortTarget;
if (groupsInSortTarget != null)
{
for (int num3 = 0; num3 < groupsInSortTarget.Count; num3++)
{
groupsInSortTarget[num3].NeedScopeInfoForSortFilterExpression = this.SetSortFilterInfo(groupsInSortTarget[num3].NeedScopeInfoForSortFilterExpression, count, j);
}
}
IntList peerSortFilters = eventSource.GetPeerSortFilters(false);
if (peerSortFilters != null)
{
if (this.m_runtimeSortFilterInfo[j].PeerSortFilters == null)
{
this.m_runtimeSortFilterInfo[j].PeerSortFilters = new Hashtable();
}
for (int num4 = 0; num4 < peerSortFilters.Count; num4++)
{
if (eventSource.ID != peerSortFilters[num4])
{
this.m_runtimeSortFilterInfo[j].PeerSortFilters.Add(peerSortFilters[num4], null);
}
}
}
}
}
return(true);
}
return(false);
}
public void Populate(ErrorContext errorContext)
{
Global.Tracer.Assert(this.m_unpopulated);
Global.Tracer.Assert(null != this.m_entries);
Hashtable hashtable = new Hashtable();
int num = -1;
if (0 < this.m_entries.Count)
{
if (this.m_normal)
{
this.m_entries.Sort();
}
this.m_nonComputedReportItems = new ReportItemList();
this.m_computedReportItems = new ReportItemList();
this.m_sortedReportItemList = new ReportItemIndexerList();
for (int i = 0; i < this.m_entries.Count; i++)
{
ReportItem reportItem = this.m_entries[i];
Global.Tracer.Assert(null != reportItem);
if (reportItem is DataRegion)
{
hashtable[reportItem.Name] = reportItem;
}
ReportItemIndexer reportItemIndexer = default(ReportItemIndexer);
if (reportItem.Computed)
{
reportItemIndexer.Index = this.m_computedReportItems.Add(reportItem);
}
else
{
reportItemIndexer.Index = this.m_nonComputedReportItems.Add(reportItem);
}
reportItemIndexer.IsComputed = reportItem.Computed;
this.m_sortedReportItemList.Add(reportItemIndexer);
}
}
this.m_unpopulated = false;
this.m_entries = null;
for (int j = 0; j < this.Count; j++)
{
ReportItem reportItem2 = this[j];
Global.Tracer.Assert(null != reportItem2);
if (reportItem2.RepeatWith != null)
{
if (reportItem2 is DataRegion || reportItem2 is SubReport || (reportItem2 is Rectangle && ((Rectangle)reportItem2).ContainsDataRegionOrSubReport()))
{
errorContext.Register(ProcessingErrorCode.rsInvalidRepeatWith, Severity.Error, reportItem2.ObjectType, reportItem2.Name, "RepeatWith");
}
if (!this.m_normal || !hashtable.ContainsKey(reportItem2.RepeatWith))
{
errorContext.Register(ProcessingErrorCode.rsRepeatWithNotPeerDataRegion, Severity.Error, reportItem2.ObjectType, reportItem2.Name, "RepeatWith", reportItem2.RepeatWith);
}
DataRegion dataRegion = (DataRegion)hashtable[reportItem2.RepeatWith];
if (dataRegion != null)
{
if (dataRegion.RepeatSiblings == null)
{
dataRegion.RepeatSiblings = new IntList();
}
dataRegion.RepeatSiblings.Add(j);
}
}
if (this.m_linkToChildName != null && num < 0 && reportItem2.Name.Equals(this.m_linkToChildName, StringComparison.Ordinal))
{
num = j;
((Rectangle)reportItem2.Parent).LinkToChild = j;
}
}
}
