public void AddSortInfoIndex(int sortInfoIndex, RuntimeSortFilterEventInfo sortInfo)
{
Global.Tracer.Assert(sortInfo.EventSource.UserSort.SortExpressionScope == null || !sortInfo.TargetSortFilterInfoAdded);
if (this.m_sortFilterInfoIndices == null)
{
this.m_sortFilterInfoIndices = new IntList();
}
this.m_sortFilterInfoIndices.Add(sortInfoIndex);
sortInfo.TargetSortFilterInfoAdded = true;
}
public void CopyTo(IntList target)
{
if (target != null)
{
target.Clear();
for (int i = 0; i < this.Count; i++)
{
target.Add(this[i]);
}
}
}
public IntList GetPeerSortFilters(bool create)
{
if (this.m_userSort == null)
{
return(null);
}
InScopeSortFilterHashtable inScopeSortFilterHashtable = null;
IntList intList = null;
if (this.m_containingScopes == null || this.m_containingScopes.Count == 0 || this.m_isSubReportTopLevelScope)
{
inScopeSortFilterHashtable = this.GetSortFiltersInScope(create, false);
}
else
{
Grouping lastEntry = this.m_containingScopes.LastEntry;
if (lastEntry == null)
{
inScopeSortFilterHashtable = this.GetSortFiltersInScope(create, true);
}
else if (this.m_userSort.SortExpressionScope == null)
{
if (lastEntry.DetailSortFiltersInScope == null && create)
{
lastEntry.DetailSortFiltersInScope = new InScopeSortFilterHashtable();
}
inScopeSortFilterHashtable = lastEntry.DetailSortFiltersInScope;
}
else
{
if (lastEntry.NonDetailSortFiltersInScope == null && create)
{
lastEntry.NonDetailSortFiltersInScope = new InScopeSortFilterHashtable();
}
inScopeSortFilterHashtable = lastEntry.NonDetailSortFiltersInScope;
}
}
if (inScopeSortFilterHashtable != null)
{
int num = (this.m_userSort.SortExpressionScope == null) ? this.m_userSort.SortTarget.ID : this.m_userSort.SortExpressionScope.ID;
intList = inScopeSortFilterHashtable[num];
if (intList == null && create)
{
intList = new IntList();
inScopeSortFilterHashtable.Add(num, intList);
}
}
return(intList);
}
public bool ClearPeerSorts(int uniqueName)
{
bool result = false;
IntList intList = null;
for (int i = 0; i < this.m_collection.Count; i++)
{
SortInfoStruct sortInfoStruct = (SortInfoStruct)this.m_collection[i];
Hashtable peerSorts = sortInfoStruct.PeerSorts;
if (peerSorts != null)
{
if (intList == null)
{
intList = new IntList();
}
if (peerSorts.Contains(uniqueName))
{
intList.Add(sortInfoStruct.ReportItemUniqueName);
}
}
}
if (intList != null)
{
if (0 < intList.Count)
{
for (int j = 0; j < intList.Count; j++)
{
this.Remove(intList[j]);
}
result = true;
}
}
else if (this.m_collection.Count > 0)
{
this.m_nameMap.Clear();
this.m_collection.Clear();
result = true;
}
return(result);
}
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 TableRow(int id, int idForReportItems)
: base(id)
{
this.m_reportItems = new ReportItemCollection(idForReportItems, false);
this.m_colSpans = new IntList();
}
public SortExpressionScopeInstanceHolder(SortFilterExpressionScopeObj owner)
{
this.m_owner = owner;
this.m_scopeInstanceIndices = new IntList();
}
public DrillthroughInformation(string reportName, DrillthroughParameters reportParameters, IntList dataSetTokenIDs)
{
this.m_reportName = reportName;
this.m_reportParameters = reportParameters;
this.m_dataSetTokenIDs = dataSetTokenIDs;
}
public SenderInformation(bool startHidden, int[] containerUniqueNames)
{
this.m_startHidden = startHidden;
this.m_receiverUniqueNames = new IntList();
this.m_containerUniqueNames = containerUniqueNames;
}
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);
}
private void RegisterOverlappingItems(InitializationContext context, int count, SortedReportItemIndexList sortedTop, bool isSortedVertically)
{
Hashtable hashtable = new Hashtable(count);
for (int i = 0; i < count - 1; i++)
{
int num = sortedTop[i];
double num2 = isSortedVertically ? this.m_entries[num].AbsoluteBottomValue : this.m_entries[num].AbsoluteRightValue;
bool flag = true;
for (int j = i + 1; j < count; j++)
{
if (!flag)
{
break;
}
int num3 = sortedTop[j];
Global.Tracer.Assert(num != num3, "(currentIndex != peerIndex)");
double num4 = isSortedVertically ? this.m_entries[num3].AbsoluteTopValue : this.m_entries[num3].AbsoluteLeftValue;
if (num2 > num4)
{
int num5 = Math.Min(num, num3);
int num6 = Math.Max(num, num3);
IntList intList = hashtable[num5] as IntList;
if (intList == null)
{
intList = new IntList();
hashtable[num5] = intList;
}
intList.Add(num6);
}
else
{
flag = false;
}
}
}
foreach (int key in hashtable.Keys)
{
IntList intList2 = hashtable[key] as IntList;
double num8 = isSortedVertically ? this.m_entries[key].AbsoluteLeftValue : this.m_entries[key].AbsoluteTopValue;
double num9 = isSortedVertically ? this.m_entries[key].AbsoluteRightValue : this.m_entries[key].AbsoluteBottomValue;
for (int k = 0; k < intList2.Count; k++)
{
int index = intList2[k];
double num10 = isSortedVertically ? this.m_entries[index].AbsoluteLeftValue : this.m_entries[index].AbsoluteTopValue;
double num11 = isSortedVertically ? this.m_entries[index].AbsoluteRightValue : this.m_entries[index].AbsoluteBottomValue;
if (num10 > num8 && num10 < num9)
{
goto IL_023a;
}
if (num11 > num8 && num11 < num9)
{
goto IL_023a;
}
if (num10 <= num8 && num9 <= num11)
{
goto IL_023a;
}
if (num8 <= num10 && num11 <= num9)
{
goto IL_023a;
}
continue;
IL_023a:
context.ErrorContext.Register(ProcessingErrorCode.rsOverlappingReportItems, Severity.Warning, this.m_entries[key].ObjectType, this.m_entries[key].Name, null, ErrorContext.GetLocalizedObjectTypeString(this.m_entries[index].ObjectType), this.m_entries[index].Name);
}
}
}
