internal object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (nonCompNames.ChildrenUniqueNames == null)
{
return(null);
}
NonComputedUniqueNames nonCompNames2 = null;
int count = m_reportItems.Count;
object obj = null;
for (int i = 0; i < count; i++)
{
nonCompNames2 = nonCompNames.ChildrenUniqueNames[i];
obj = ((ISearchByUniqueName)m_reportItems[i]).Find(targetUniqueName, ref nonCompNames2, chunkManager);
if (obj != null)
{
break;
}
}
if (obj != null)
{
nonCompNames = nonCompNames2;
return(obj);
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
int count = m_reportItemColDef.Count;
for (int i = 0; i < count; i++)
{
m_reportItemColDef.GetReportItem(i, out bool computed, out int internalIndex, out ReportItem reportItem);
if (computed)
{
obj = ((ISearchByUniqueName)m_reportItemInstances[internalIndex]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
continue;
}
NonComputedUniqueNames nonCompNames2 = GetInstanceInfo(chunkManager, inPageSection: false).ChildrenNonComputedUniqueNames[internalIndex];
obj = ((ISearchByUniqueName)reportItem).Find(targetUniqueName, ref nonCompNames2, chunkManager);
if (obj != null)
{
nonCompNames = nonCompNames2;
return(obj);
}
}
return(null);
}
protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (m_reportInstance == null)
{
return(null);
}
return(((ISearchByUniqueName)m_reportInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
nonCompNames = null;
if (index < 0 || index >= m_reportItems.Count)
{
return(null);
}
return(m_reportItems[index]);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (m_uniqueName == targetUniqueName)
{
nonCompNames = null;
return(this);
}
return(SearchChildren(targetUniqueName, ref nonCompNames, chunkManager));
}
internal MatrixCellInstance AddCell(ReportProcessing.ProcessingContext pc, out NonComputedUniqueNames cellNonComputedUniqueNames)
{
Matrix matrix = (Matrix)m_reportItemDef;
int currentCellRIIndex = GetCurrentCellRIIndex();
bool flag = matrix.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column;
int num;
int colIndex;
if (flag)
{
num = m_currentOuterStaticIndex;
colIndex = m_currentInnerStaticIndex;
}
else
{
colIndex = m_currentOuterStaticIndex;
num = m_currentInnerStaticIndex;
}
MatrixCellInstance matrixCellInstance = null;
matrixCellInstance = ((pc.HeadingInstance == null || pc.HeadingInstance.MatrixHeadingDef.Subtotal.StyleClass == null) ? new MatrixCellInstance(num, colIndex, matrix, currentCellRIIndex, pc, out cellNonComputedUniqueNames) : new MatrixSubtotalCellInstance(num, colIndex, matrix, currentCellRIIndex, pc, out cellNonComputedUniqueNames));
if ((!flag && m_currentCellOuterIndex == 0) || (flag && m_currentCellInnerIndex == 0))
{
if (!pc.Pagination.IgnoreHeight)
{
pc.Pagination.AddToCurrentPageHeight(matrix, matrix.MatrixRows[num].HeightValue);
}
if (!pc.Pagination.IgnorePageBreak && pc.Pagination.CurrentPageHeight >= pc.Pagination.PageHeight && m_rowInstances.Count > 1)
{
pc.Pagination.SetCurrentPageHeight(matrix, 0.0);
m_extraPagesFilled++;
matrix.CurrentPage = m_startPage + m_extraPagesFilled;
m_numberOfChildrenOnThisPage = 0;
}
else
{
m_numberOfChildrenOnThisPage++;
}
}
if (matrix.ProcessingInnerGrouping == Pivot.ProcessingInnerGroupings.Column)
{
m_cells[m_currentCellOuterIndex].Add(matrixCellInstance);
}
else
{
if (m_currentCellOuterIndex == 0)
{
Global.Tracer.Assert(m_cells.Count == m_currentCellInnerIndex);
MatrixCellInstanceList value = new MatrixCellInstanceList();
m_cells.Add(value);
}
m_cells[m_currentCellInnerIndex].Add(matrixCellInstance);
}
m_currentCellInnerIndex++;
return(matrixCellInstance);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
if (m_headerRowInstances != null)
{
int num = m_headerRowInstances.Length;
for (int i = 0; i < num; i++)
{
obj = ((ISearchByUniqueName)m_headerRowInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
if (m_subGroupInstances != null)
{
int count = m_subGroupInstances.Count;
for (int j = 0; j < count; j++)
{
obj = ((ISearchByUniqueName)m_subGroupInstances[j]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
else if (m_tableDetailInstances != null)
{
int count2 = m_tableDetailInstances.Count;
for (int k = 0; k < count2; k++)
{
obj = ((ISearchByUniqueName)m_tableDetailInstances[k]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
if (m_footerRowInstances != null)
{
int num2 = m_footerRowInstances.Length;
for (int l = 0; l < num2; l++)
{
obj = ((ISearchByUniqueName)m_footerRowInstances[l]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
return(null);
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
m_reportItemColDef.GetReportItem(index, out bool computed, out int internalIndex, out ReportItem reportItem);
if (computed)
{
nonCompNames = null;
return(m_reportItemInstances[internalIndex]);
}
nonCompNames = ((ReportItemColInstanceInfo)m_instanceInfo).ChildrenNonComputedUniqueNames[internalIndex];
return(reportItem);
}
internal void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames[] nonCompNames)
{
if (nonCompNames != null && m_nonComputedReportItems != null && m_nonComputedReportItems.Count != 0)
{
NonComputedUniqueNames nonComputedUniqueNames = null;
for (int i = 0; i < m_nonComputedReportItems.Count; i++)
{
nonComputedUniqueNames = nonCompNames[i];
m_nonComputedReportItems[i].ProcessDrillthroughAction(processingContext, nonComputedUniqueNames);
}
}
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
if (nonCompNames == null)
{
return(null);
}
if (targetUniqueName == nonCompNames.UniqueName)
{
return(this);
}
return((this as Rectangle)?.SearchChildren(targetUniqueName, ref nonCompNames, chunkManager));
}
internal override void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
{
if (nonCompNames != null && nonCompNames.ChildrenUniqueNames != null)
{
NonComputedUniqueNames nonComputedUniqueNames = null;
int count = m_reportItems.Count;
for (int i = 0; i < count; i++)
{
nonComputedUniqueNames = nonCompNames.ChildrenUniqueNames[i];
m_reportItems[i].ProcessDrillthroughAction(processingContext, nonComputedUniqueNames);
}
}
}
internal ReportItemColInstance(ReportProcessing.ProcessingContext pc, ReportItemCollection reportItemsDef)
{
m_reportItemColDef = reportItemsDef;
if (reportItemsDef.ComputedReportItems != null)
{
m_reportItemInstances = new ReportItemInstanceList(reportItemsDef.ComputedReportItems.Count);
}
if (pc != null)
{
m_childrenNonComputedUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItemsDef);
}
m_instanceInfo = new ReportItemColInstanceInfo(pc, reportItemsDef, this);
}
protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
int count = m_listContentInstances.Count;
for (int i = 0; i < count; i++)
{
object obj = ((ISearchByUniqueName)m_listContentInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
int count = 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);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
if (m_detailRowInstances != null)
{
int num = m_detailRowInstances.Length;
for (int i = 0; i < num; i++)
{
obj = ((ISearchByUniqueName)m_detailRowInstances[i]).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
return(null);
}
internal 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 == groupExpressionValues[0])
{
m_groupExpressionValue = null;
}
else
{
m_groupExpressionValue = groupExpressionValues[0];
}
}
}
if (0 < reportItems.Count && !reportItems.IsReportItemComputed(reportItemDefIndex))
{
m_contentUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItems[reportItemDefIndex]);
}
nonComputedUniqueNames = m_contentUniqueNames;
m_headingCellIndex = headingCellIndex;
if (!isSubtotal && pc.ShowHideType != 0)
{
m_startHidden = pc.ProcessReceiver(owner.UniqueName, matrixHeadingDef.Visibility, matrixHeadingDef.ExprHost, matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name);
}
if (matrixHeadingDef.Grouping != null && matrixHeadingDef.Grouping.GroupLabel != null)
{
m_label = pc.NavigationInfo.RegisterLabel(pc.ReportRuntime.EvaluateGroupingLabelExpression(matrixHeadingDef.Grouping, matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name));
}
if (matrixHeadingDef.Grouping != null && matrixHeadingDef.Grouping.CustomProperties != null)
{
m_customPropertyInstances = matrixHeadingDef.Grouping.CustomProperties.EvaluateExpressions(matrixHeadingDef.DataRegionDef.ObjectType, matrixHeadingDef.DataRegionDef.Name, matrixHeadingDef.Grouping.Name + ".", pc);
}
matrixHeadingDef.StartHidden = m_startHidden;
}
internal MatrixCellInstanceInfo(int rowIndex, int colIndex, Matrix matrixDef, int cellDefIndex, ReportProcessing.ProcessingContext pc, MatrixCellInstance owner, out NonComputedUniqueNames nonComputedUniqueNames)
{
m_rowIndex = rowIndex;
m_columnIndex = colIndex;
if (0 < matrixDef.CellReportItems.Count && !matrixDef.CellReportItems.IsReportItemComputed(cellDefIndex))
{
m_contentUniqueNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, matrixDef.CellReportItems[cellDefIndex]);
}
nonComputedUniqueNames = 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);
}
}
internal int ProcessNavigationChildren(ReportProcessing.NavigationInfo navigationInfo, NonComputedUniqueNames nonCompNames, int startPage)
{
if (nonCompNames.ChildrenUniqueNames == null)
{
return(-1);
}
NonComputedUniqueNames nonComputedUniqueNames = null;
int count = m_reportItems.Count;
int result = -1;
for (int i = 0; i < count; i++)
{
nonComputedUniqueNames = nonCompNames.ChildrenUniqueNames[i];
if (i == m_linkToChild)
{
result = nonComputedUniqueNames.UniqueName;
}
m_reportItems[i].ProcessNavigationAction(navigationInfo, nonComputedUniqueNames, startPage);
}
return(result);
}
internal MatrixInstanceInfo(ReportProcessing.ProcessingContext pc, Matrix reportItemDef, MatrixInstance owner)
: base(pc, reportItemDef, owner, addToChunk: false)
{
if (0 < reportItemDef.CornerReportItems.Count && !reportItemDef.CornerReportItems.IsReportItemComputed(0))
{
m_cornerNonComputedNames = NonComputedUniqueNames.CreateNonComputedUniqueNames(pc, reportItemDef.CornerReportItems[0]);
}
reportItemDef.CornerNonComputedUniqueNames = 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);
}
}
m_noRows = pc.ReportRuntime.EvaluateDataRegionNoRowsExpression(reportItemDef, reportItemDef.ObjectType, reportItemDef.Name, "NoRows");
}
internal static NonComputedUniqueNames[] CreateNonComputedUniqueNames(ReportProcessing.ProcessingContext pc, ReportItemCollection reportItemsDef)
{
if (reportItemsDef == null || pc == null)
{
return(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] = CreateNonComputedUniqueNames(pc, nonComputedReportItems[i]);
}
return(array);
}
internal object Find(int index, int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
ReportItemCollection reportItemCollection = (!IsSubtotal) ? MatrixHeadingDef.ReportItems : MatrixHeadingDef.Subtotal.ReportItems;
if (reportItemCollection.Count > 0)
{
if (reportItemCollection.Count == 1)
{
index = 0;
}
if (reportItemCollection.IsReportItemComputed(index))
{
Global.Tracer.Assert(m_content != null, "The instance of a computed report item cannot be null.");
obj = ((ISearchByUniqueName)m_content).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
else
{
NonComputedUniqueNames nonCompNames2 = GetInstanceInfo(chunkManager).ContentUniqueNames;
obj = ((ISearchByUniqueName)reportItemCollection[index]).Find(targetUniqueName, ref nonCompNames2, chunkManager);
if (obj != null)
{
nonCompNames = nonCompNames2;
return(obj);
}
}
}
if (m_subHeadingInstances != null)
{
return(((ISearchByUniqueName)m_subHeadingInstances).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
return(null);
}
object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
return(((ISearchByUniqueName)m_reportItemColInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
}
internal void ProcessNavigationAction(ReportProcessing.NavigationInfo navigationInfo, NonComputedUniqueNames nonCompNames, int startPage)
{
if (nonCompNames == null)
{
return;
}
if (m_bookmark != null && m_bookmark.Value != null)
{
navigationInfo.ProcessBookmark(m_bookmark.Value, startPage, nonCompNames.UniqueName);
}
Rectangle rectangle = this as Rectangle;
if (m_label != null && m_label.Value != null)
{
int num = -1;
if (rectangle != null)
{
navigationInfo.EnterDocumentMapChildren();
num = rectangle.ProcessNavigationChildren(navigationInfo, nonCompNames, startPage);
}
if (num < 0)
{
num = nonCompNames.UniqueName;
}
navigationInfo.AddToDocumentMap(num, rectangle != null, startPage, m_label.Value);
}
else
{
rectangle?.ProcessNavigationChildren(navigationInfo, nonCompNames, startPage);
}
}
internal 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(pc.HeadingInstance != null);
Global.Tracer.Assert(pc.HeadingInstance.MatrixHeadingDef.Subtotal.StyleClass != null);
m_subtotalHeadingInstance = pc.HeadingInstance;
}
protected virtual object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
return(null);
}
internal virtual void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
{
}
internal 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(matrixHeadingDef.Subtotal != null);
Global.Tracer.Assert(matrixHeadingDef.Subtotal.StyleClass != null);
if (matrixHeadingDef.Subtotal.StyleClass.ExpressionList != null)
{
m_styleAttributeValues = new object[matrixHeadingDef.Subtotal.StyleClass.ExpressionList.Count];
ReportProcessing.RuntimeRICollection.EvaluateStyleAttributes(ObjectType.Subtotal, matrixHeadingDef.Grouping.Name, matrixHeadingDef.Subtotal.StyleClass, owner.UniqueName, m_styleAttributeValues, pc);
}
}
protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
{
object obj = null;
Matrix matrix = (Matrix)base.ReportItemDef;
if (matrix.CornerReportItems.Count > 0)
{
if (m_cornerContent != null)
{
obj = ((ISearchByUniqueName)m_cornerContent).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
else
{
NonComputedUniqueNames nonCompNames2 = ((MatrixInstanceInfo)GetInstanceInfo(chunkManager, inPageSection: false)).CornerNonComputedNames;
obj = ((ISearchByUniqueName)matrix.CornerReportItems[0]).Find(targetUniqueName, ref nonCompNames2, chunkManager);
if (obj != null)
{
nonCompNames = nonCompNames2;
return(obj);
}
}
}
obj = ((ISearchByUniqueName)m_columnInstances).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
obj = ((ISearchByUniqueName)m_rowInstances).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
int count = m_cells.Count;
for (int i = 0; i < count; i++)
{
MatrixCellInstanceList matrixCellInstanceList = m_cells[i];
int count2 = matrixCellInstanceList.Count;
for (int j = 0; j < count2; j++)
{
MatrixCellInstance matrixCellInstance = matrixCellInstanceList[j];
MatrixCellInstanceInfo instanceInfo = matrixCellInstance.GetInstanceInfo(chunkManager);
int index = instanceInfo.RowIndex * matrix.MatrixColumns.Count + instanceInfo.ColumnIndex;
if (matrix.CellReportItems.IsReportItemComputed(index))
{
if (matrixCellInstance.Content != null)
{
obj = ((ISearchByUniqueName)matrixCellInstance.Content).Find(targetUniqueName, ref nonCompNames, chunkManager);
if (obj != null)
{
return(obj);
}
}
}
else
{
NonComputedUniqueNames nonCompNames3 = instanceInfo.ContentUniqueNames;
obj = ((ISearchByUniqueName)matrix.CellReportItems[index]).Find(targetUniqueName, ref nonCompNames3, chunkManager);
if (obj != null)
{
nonCompNames = nonCompNames3;
return(obj);
}
}
}
}
return(null);
}
object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
{
return(((IIndexInto)m_reportItemColInstance).GetChildAt(index, out nonCompNames));
}
internal override void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
{
if (m_action != null && nonCompNames != null)
{
m_action.ProcessDrillthroughAction(processingContext, nonCompNames.UniqueName);
}
}