public void ResolveReferences(Dictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
List <MemberReference> list = default(List <MemberReference>);
if (memberReferencesCollection.TryGetValue(EndUserSort.m_Declaration.ObjectType, out list))
{
foreach (MemberReference item in list)
{
switch (item.MemberName)
{
case MemberName.DataSet:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is DataSet);
Global.Tracer.Assert(this.m_dataSet != (DataSet)referenceableItems[item.RefID]);
this.m_dataSet = (DataSet)referenceableItems[item.RefID];
break;
case MemberName.SortTarget:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is ISortFilterScope);
Global.Tracer.Assert(this.m_sortTarget != (ISortFilterScope)referenceableItems[item.RefID]);
this.m_sortTarget = (ISortFilterScope)referenceableItems[item.RefID];
break;
case MemberName.DetailScopeSubReports:
if (this.m_detailScopeSubReports == null)
{
this.m_detailScopeSubReports = new List <SubReport>();
}
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is SubReport);
Global.Tracer.Assert(!this.m_detailScopeSubReports.Contains((SubReport)referenceableItems[item.RefID]));
this.m_detailScopeSubReports.Add((SubReport)referenceableItems[item.RefID]);
break;
case MemberName.SortExpressionScope:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is ISortFilterScope);
Global.Tracer.Assert(this.m_sortExpressionScope != (ISortFilterScope)referenceableItems[item.RefID]);
this.m_sortExpressionScope = (ISortFilterScope)referenceableItems[item.RefID];
break;
case MemberName.GroupsInSortTarget:
if (this.m_groupsInSortTarget == null)
{
this.m_groupsInSortTarget = new GroupingList();
}
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is Grouping);
Global.Tracer.Assert(!this.m_groupsInSortTarget.Contains((Grouping)referenceableItems[item.RefID]));
this.m_groupsInSortTarget.Add((Grouping)referenceableItems[item.RefID]);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
}
public void ResolveReferences(Dictionary <Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType, List <MemberReference> > memberReferencesCollection, Dictionary <int, IReferenceable> referenceableItems)
{
if (!memberReferencesCollection.TryGetValue(m_Declaration.ObjectType, out List <MemberReference> value))
{
return;
}
foreach (MemberReference item in value)
{
switch (item.MemberName)
{
case MemberName.DataSet:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is DataSet);
Global.Tracer.Assert(m_dataSet != (DataSet)referenceableItems[item.RefID]);
m_dataSet = (DataSet)referenceableItems[item.RefID];
break;
case MemberName.SortTarget:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is ISortFilterScope);
Global.Tracer.Assert(m_sortTarget != (ISortFilterScope)referenceableItems[item.RefID]);
m_sortTarget = (ISortFilterScope)referenceableItems[item.RefID];
break;
case MemberName.DetailScopeSubReports:
if (m_detailScopeSubReports == null)
{
m_detailScopeSubReports = new List <SubReport>();
}
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is SubReport);
Global.Tracer.Assert(!m_detailScopeSubReports.Contains((SubReport)referenceableItems[item.RefID]));
m_detailScopeSubReports.Add((SubReport)referenceableItems[item.RefID]);
break;
case MemberName.SortExpressionScope:
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is ISortFilterScope);
Global.Tracer.Assert(m_sortExpressionScope != (ISortFilterScope)referenceableItems[item.RefID]);
m_sortExpressionScope = (ISortFilterScope)referenceableItems[item.RefID];
break;
case MemberName.GroupsInSortTarget:
if (m_groupsInSortTarget == null)
{
m_groupsInSortTarget = new GroupingList();
}
Global.Tracer.Assert(referenceableItems.ContainsKey(item.RefID));
Global.Tracer.Assert(referenceableItems[item.RefID] is Grouping);
Global.Tracer.Assert(!m_groupsInSortTarget.Contains((Grouping)referenceableItems[item.RefID]));
m_groupsInSortTarget.Add((Grouping)referenceableItems[item.RefID]);
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public void SetSortTarget(ISortFilterScope target)
{
Global.Tracer.Assert(null != target);
this.m_sortTarget = target;
if (target.UserSortExpressions == null)
{
target.UserSortExpressions = new List <ExpressionInfo>();
}
this.m_sortExpressionIndex = target.UserSortExpressions.Count;
target.UserSortExpressions.Add(this.m_sortExpression);
}
internal void SetSortTarget(ISortFilterScope target)
{
Global.Tracer.Assert(target != null);
m_sortTarget = target;
if (target.UserSortExpressions == null)
{
target.UserSortExpressions = new ExpressionInfoList();
}
m_sortExpressionIndex = target.UserSortExpressions.Count;
target.UserSortExpressions.Add(m_sortExpression);
}
public void UpdateSortScopeAndTargetReference(AutomaticSubtotalContext context)
{
if (this.m_sortExpressionScopeString != null)
{
this.m_sortExpressionScopeString = context.GetNewScopeName(this.m_sortExpressionScopeString);
}
if (this.m_sortTargetString != null)
{
this.m_sortTargetString = context.GetNewScopeName(this.m_sortTargetString);
if (this.m_sortTarget != null)
{
ISortFilterScope sortTarget = null;
if (context.TryGetNewSortTarget(this.m_sortTargetString, out sortTarget))
{
this.SetSortTarget(sortTarget);
}
}
}
}
internal void UpdateSortScopeAndTargetReference(AutomaticSubtotalContext context)
{
if (m_sortExpressionScopeString != null)
{
m_sortExpressionScopeString = context.GetNewScopeName(m_sortExpressionScopeString);
}
if (m_sortTargetString == null)
{
return;
}
m_sortTargetString = context.GetNewScopeName(m_sortTargetString);
if (m_sortTarget != null)
{
ISortFilterScope target = null;
if (context.TryGetNewSortTarget(m_sortTargetString, out target))
{
SetSortTarget(target);
}
}
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(EndUserSort.m_Declaration);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.DataSet:
this.m_dataSet = reader.ReadReference <DataSet>(this);
break;
case MemberName.SortExpressionScope:
this.m_sortExpressionScope = reader.ReadReference <ISortFilterScope>(this);
break;
case MemberName.GroupsInSortTarget:
this.m_groupsInSortTarget = reader.ReadListOfReferences <GroupingList, Grouping>(this);
break;
case MemberName.SortTarget:
this.m_sortTarget = reader.ReadReference <ISortFilterScope>(this);
break;
case MemberName.SortExpressionIndex:
this.m_sortExpressionIndex = reader.ReadInt32();
break;
case MemberName.DetailScopeSubReports:
this.m_detailScopeSubReports = reader.ReadGenericListOfReferences <SubReport>(this);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public void SetDefaultSortTarget(ISortFilterScope target)
{
this.SetSortTarget(target);
this.m_sortTargetString = target.ScopeName;
}
internal bool PopulateRuntimeSortFilterEventInfo(ReportProcessing.ProcessingContext pc, DataSet myDataSet)
{
if (pc.UserSortFilterInfo == null || pc.UserSortFilterInfo.SortInfo == null || pc.OldSortFilterEventInfo == null)
{
return(false);
}
if (m_dataSetID != -1)
{
return(false);
}
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 (m_runtimeSortFilterInfo == null)
{
m_runtimeSortFilterInfo = new RuntimeSortFilterEventInfoList();
}
m_runtimeSortFilterInfo.Add(new RuntimeSortFilterEventInfo(sortFilterEventInfo.EventSource, uniqueNameAt, sortInfo.GetSortDirectionAt(i), sortFilterEventInfo.EventSourceScopeInfo));
}
}
if (m_runtimeSortFilterInfo != null)
{
int count = m_runtimeSortFilterInfo.Count;
for (int j = 0; j < count; j++)
{
TextBox eventSource = m_runtimeSortFilterInfo[j].EventSource;
ISortFilterScope sortExpressionScope = eventSource.UserSort.SortExpressionScope;
if (sortExpressionScope != null)
{
sortExpressionScope.IsSortFilterExpressionScope = SetSortFilterInfo(sortExpressionScope.IsSortFilterExpressionScope, count, j);
}
ISortFilterScope sortTarget = eventSource.UserSort.SortTarget;
if (sortTarget != null)
{
sortTarget.IsSortFilterTarget = 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 = 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;
continue;
}
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)variantList[0];
}
}
GroupingList groupsInSortTarget = eventSource.UserSort.GroupsInSortTarget;
if (groupsInSortTarget != null)
{
for (int num2 = 0; num2 < groupsInSortTarget.Count; num2++)
{
groupsInSortTarget[num2].NeedScopeInfoForSortFilterExpression = SetSortFilterInfo(groupsInSortTarget[num2].NeedScopeInfoForSortFilterExpression, count, j);
}
}
IntList peerSortFilters = eventSource.GetPeerSortFilters(create: false);
if (peerSortFilters == null)
{
continue;
}
if (m_runtimeSortFilterInfo[j].PeerSortFilters == null)
{
m_runtimeSortFilterInfo[j].PeerSortFilters = new Hashtable();
}
for (int num3 = 0; num3 < peerSortFilters.Count; num3++)
{
if (eventSource.ID != peerSortFilters[num3])
{
m_runtimeSortFilterInfo[j].PeerSortFilters.Add(peerSortFilters[num3], null);
}
}
}
}
return(true);
}
internal void SetDefaultSortTarget(ISortFilterScope target)
{
SetSortTarget(target);
m_sortTargetString = target.ScopeName;
}
