public object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (nonCompNames.ChildrenUniqueNames == null)
{
return(null);
}
NonComputedUniqueNames nonComputedUniqueNames = null;
int count = this.m_reportItems.Count;
object obj = null;
for (int i = 0; i < count; i++)
{
nonComputedUniqueNames = nonCompNames.ChildrenUniqueNames[i];
obj = ((ISearchByUniqueName)this.m_reportItems[i]).Find(targetUniqueName, ref nonComputedUniqueNames, chunkManager);
if (obj != null)
{
break;
}
}
if (obj != null)
{
nonCompNames = nonComputedUniqueNames;
return(obj);
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
int count = this.m_reportItemColDef.Count;
for (int i = 0; i < count; i++)
{
bool flag = default(bool);
int num = default(int);
ReportItem reportItem = default(ReportItem);
this.m_reportItemColDef.GetReportItem(i, out flag, out num, out reportItem);
if (flag)
{
obj = ((ISearchByUniqueName)this.m_reportItemInstances[num]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
else
{
NonComputedUniqueNames nonComputedUniqueNames = this.GetInstanceInfo(chunkManager, false).ChildrenNonComputedUniqueNames[num];
obj = ((ISearchByUniqueName)reportItem).Find(targetUniqueName, ref nonComputedUniqueNames, chunkManager);
if (obj != null)
{
nonCompNames = nonComputedUniqueNames;
return(obj);
}
}
}
return(null);
}
protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (this.m_reportInstance == null)
{
return(null);
}
return(((ISearchByUniqueName)this.m_reportInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
nonCompNames = null;
if (index >= 0 && index < this.m_reportItems.Count)
{
return(this.m_reportItems[index]);
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (this.m_uniqueName == targetUniqueName)
{
nonCompNames = null;
return(this);
}
return(this.SearchChildren(targetUniqueName, ref nonCompNames, chunkManager));
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
if (this.m_headerRowInstances != null)
{
int num = this.m_headerRowInstances.Length;
for (int i = 0; i < num; i++)
{
obj = ((ISearchByUniqueName)this.m_headerRowInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
if (this.m_subGroupInstances != null)
{
int count = this.m_subGroupInstances.Count;
for (int j = 0; j < count; j++)
{
obj = ((ISearchByUniqueName)this.m_subGroupInstances[j]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
else if (this.m_tableDetailInstances != null)
{
int count2 = this.m_tableDetailInstances.Count;
for (int k = 0; k < count2; k++)
{
obj = ((ISearchByUniqueName)this.m_tableDetailInstances[k]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
if (this.m_footerRowInstances != null)
{
int num2 = this.m_footerRowInstances.Length;
for (int l = 0; l < num2; l++)
{
obj = ((ISearchByUniqueName)this.m_footerRowInstances[l]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
return(null);
}
public void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames[] nonCompNames)
{
if (nonCompNames != null && this.m_nonComputedReportItems != null && this.m_nonComputedReportItems.Count != 0)
{
NonComputedUniqueNames nonComputedUniqueNames = null;
for (int i = 0; i < this.m_nonComputedReportItems.Count; i++)
{
nonComputedUniqueNames = nonCompNames[i];
this.m_nonComputedReportItems[i].ProcessDrillthroughAction(processingContext, nonComputedUniqueNames);
}
}
}
public ReportItemColInstance(ReportProcessing.ProcessingContext pc, ReportItemCollection reportItemsDef)
{
this.m_reportItemColDef = reportItemsDef;
if (reportItemsDef.ComputedReportItems != null)
{
this.m_reportItemInstances = new ReportItemInstanceList(reportItemsDef.ComputedReportItems.Count);
}
if (pc != null)
{
this.m_childrenNonComputedUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItemsDef);
}
base.m_instanceInfo = new ReportItemColInstanceInfo(pc, reportItemsDef, this);
}
public override void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
{
if (nonCompNames != null && nonCompNames.ChildrenUniqueNames != null)
{
NonComputedUniqueNames nonComputedUniqueNames = null;
int count = this.m_reportItems.Count;
for (int i = 0; i < count; i++)
{
nonComputedUniqueNames = nonCompNames.ChildrenUniqueNames[i];
this.m_reportItems[i].ProcessDrillthroughAction(processingContext, nonComputedUniqueNames);
}
}
}
public static NonComputedUniqueNames CreateNonComputedUniqueNames(ReportProcessing.ProcessingContext pc, ReportItem reportItemDef)
{
if (reportItemDef != null && pc != null)
{
NonComputedUniqueNames[] childrenUniqueNames = null;
if (reportItemDef is Rectangle)
{
childrenUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, ((Rectangle)reportItemDef).ReportItems);
}
return(new NonComputedUniqueNames(pc.CreateUniqueName(), childrenUniqueNames));
}
return(null);
}
protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
int count = this.m_listContentInstances.Count;
for (int i = 0; i < count; i++)
{
object obj = ((ISearchByUniqueName)this.m_listContentInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
return(null);
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
bool flag = default(bool);
int num = default(int);
ReportItem result = default(ReportItem);
this.m_reportItemColDef.GetReportItem(index, out flag, out num, out result);
if (flag)
{
nonCompNames = null;
return(this.m_reportItemInstances[num]);
}
nonCompNames = ((ReportItemColInstanceInfo)base.m_instanceInfo).ChildrenNonComputedUniqueNames[num];
return(result);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
int count = this.Count;
object obj = null;
for (int i = 0; i < count; i++)
{
obj = this[i].Find(i, targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
break;
}
}
return(obj);
}
public int GetReportItemUniqueName(int index)
{
int num = -1;
ReportItem reportItem = null;
Global.Tracer.Assert(index >= 0 && index < this.m_reportItemColDef.Count);
bool flag = default(bool);
int num2 = default(int);
this.m_reportItemColDef.GetReportItem(index, out flag, out num2, out reportItem);
if (!flag)
{
NonComputedUniqueNames nonComputedUniqueNames = this.m_childrenNonComputedUniqueNames[num2];
return(nonComputedUniqueNames.UniqueName);
}
return(this.m_reportItemInstances[num2].UniqueName);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (nonCompNames == null)
{
return(null);
}
if (targetUniqueName == nonCompNames.UniqueName)
{
return(this);
}
Rectangle rectangle = this as Rectangle;
if (rectangle != null)
{
return(rectangle.SearchChildren(targetUniqueName, ref nonCompNames, chunkManager));
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
if (this.m_detailRowInstances != null)
{
int num = this.m_detailRowInstances.Length;
for (int i = 0; i < num; i++)
{
obj = ((ISearchByUniqueName)this.m_detailRowInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
return(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 MatrixCellInstanceInfo(int rowIndex, int colIndex, Matrix matrixDef, int cellDefIndex, ReportProcessing.ProcessingContext pc, MatrixCellInstance owner, out NonComputedUniqueNames nonComputedUniqueNames)
{
this.m_rowIndex = rowIndex;
this.m_columnIndex = colIndex;
if (0 < matrixDef.CellReportItems.Count && !matrixDef.CellReportItems.IsReportItemComputed(cellDefIndex))
{
this.m_contentUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, matrixDef.CellReportItems[cellDefIndex]);
}
nonComputedUniqueNames = this.m_contentUniqueNames;
Global.Tracer.Assert(cellDefIndex < matrixDef.FirstCellInstances.Count);
if (matrixDef.FirstCellInstances[cellDefIndex])
{
pc.ChunkManager.AddInstanceToFirstPage(this, owner, pc.InPageSection);
matrixDef.FirstCellInstances[cellDefIndex] = false;
}
else
{
pc.ChunkManager.AddInstance(this, owner, pc.InPageSection);
}
}
public int ProcessNavigationChildren(ReportProcessing.NavigationInfo navigationInfo, NonComputedUniqueNames nonCompNames, int startPage)
{
if (nonCompNames.ChildrenUniqueNames == null)
{
return(-1);
}
NonComputedUniqueNames nonComputedUniqueNames = null;
int count = this.m_reportItems.Count;
int result = -1;
for (int i = 0; i < count; i++)
{
nonComputedUniqueNames = nonCompNames.ChildrenUniqueNames[i];
if (i == this.m_linkToChild)
{
result = nonComputedUniqueNames.UniqueName;
}
this.m_reportItems[i].ProcessNavigationAction(navigationInfo, nonComputedUniqueNames, startPage);
}
return(result);
}
public MatrixInstanceInfo(ReportProcessing.ProcessingContext pc, Matrix reportItemDef, MatrixInstance owner)
: base(pc, reportItemDef, owner, false)
{
if (0 < reportItemDef.CornerReportItems.Count && !reportItemDef.CornerReportItems.IsReportItemComputed(0))
{
this.m_cornerNonComputedNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItemDef.CornerReportItems[0]);
}
reportItemDef.CornerNonComputedUniqueNames = this.m_cornerNonComputedNames;
if (!pc.DelayAddingInstanceInfo)
{
if (reportItemDef.FirstInstance)
{
pc.ChunkManager.AddInstanceToFirstPage(this, owner, pc.InPageSection);
reportItemDef.FirstInstance = false;
}
else
{
pc.ChunkManager.AddInstance(this, owner, pc.InPageSection);
}
}
this.m_noRows = pc.ReportRuntime.EvaluateDataRegionNoRowsExpression(reportItemDef, reportItemDef.ObjectType, reportItemDef.Name, "NoRows");
}
public static NonComputedUniqueNames[] CreateNonComputedUniqueNames(ReportProcessing.ProcessingContext pc, ReportItemCollection reportItemsDef)
{
if (reportItemsDef != null && pc != null)
{
ReportItemList nonComputedReportItems = reportItemsDef.NonComputedReportItems;
if (nonComputedReportItems == null)
{
return(null);
}
if (nonComputedReportItems.Count == 0)
{
return(null);
}
NonComputedUniqueNames[] array = new NonComputedUniqueNames[nonComputedReportItems.Count];
for (int i = 0; i < nonComputedReportItems.Count; i++)
{
array[i] = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, nonComputedReportItems[i]);
}
return(array);
}
return(null);
}
public object Find(int index, int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
ReportItemCollection reportItemCollection = (!this.IsSubtotal) ? this.MatrixHeadingDef.ReportItems : this.MatrixHeadingDef.Subtotal.ReportItems;
if (reportItemCollection.Count > 0)
{
if (reportItemCollection.Count == 1)
{
index = 0;
}
if (reportItemCollection.IsReportItemComputed(index))
{
Global.Tracer.Assert(this.m_content != null, "The instance of a computed report item cannot be null.");
obj = ((ISearchByUniqueName)this.m_content).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
else
{
NonComputedUniqueNames contentUniqueNames = this.GetInstanceInfo(chunkManager).ContentUniqueNames;
obj = ((ISearchByUniqueName)reportItemCollection[index]).Find(targetUniqueName, ref contentUniqueNames, chunkManager);
if (obj != null)
{
nonCompNames = contentUniqueNames;
return(obj);
}
}
}
if (this.m_subHeadingInstances != null)
{
return(((ISearchByUniqueName)this.m_subHeadingInstances).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
return(null);
}
protected virtual object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
return(null);
}
public override void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
{
if (this.m_action != null && nonCompNames != null)
{
this.m_action.ProcessDrillthroughAction(processingContext, nonCompNames.UniqueName);
}
}
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 MatrixCellInstance(int rowIndex, int colIndex, Matrix matrixDef, int cellDefIndex, ReportProcessing.ProcessingContext pc, out NonComputedUniqueNames nonComputedUniqueNames)
{
base.m_instanceInfo = new MatrixCellInstanceInfo(rowIndex, colIndex, matrixDef, cellDefIndex, pc, this, out nonComputedUniqueNames);
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
return(((IIndexInto)this.m_reportItemColInstance).GetChildAt(index, out nonCompNames));
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
return(((ISearchByUniqueName)this.m_reportItemColInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
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);
}
}
public MatrixSubtotalCellInstance(int rowIndex, int colIndex, Matrix matrixDef, int cellDefIndex, ReportProcessing.ProcessingContext pc, out NonComputedUniqueNames nonComputedUniqueNames)
: base(rowIndex, colIndex, matrixDef, cellDefIndex, pc, out nonComputedUniqueNames)
{
Global.Tracer.Assert(null != pc.HeadingInstance);
Global.Tracer.Assert(null != pc.HeadingInstance.MatrixHeadingDef.Subtotal.StyleClass);
this.m_subtotalHeadingInstance = pc.HeadingInstance;
}
