Пример #1
0
        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));
 }
Пример #4
0
 object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
 {
     nonCompNames = null;
     if (index < 0 || index >= m_reportItems.Count)
     {
         return(null);
     }
     return(m_reportItems[index]);
 }
Пример #5
0
 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));
 }
Пример #6
0
        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);
        }
Пример #7
0
        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);
 }
Пример #9
0
 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);
         }
     }
 }
Пример #10
0
 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));
 }
Пример #11
0
 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);
 }
Пример #13
0
        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);
        }
Пример #14
0
        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;
        }
Пример #17
0
 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);
     }
 }
Пример #18
0
        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);
        }
Пример #19
0
 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);
        }
Пример #21
0
        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);
        }
Пример #22
0
 object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
 {
     return(((ISearchByUniqueName)m_reportItemColInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
 }
Пример #23
0
        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;
 }
Пример #25
0
 protected virtual object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
 {
     return(null);
 }
Пример #26
0
 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);
     }
 }
Пример #28
0
        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);
        }
Пример #29
0
 object IIndexInto.GetChildAt(int index, out NonComputedUniqueNames nonCompNames)
 {
     return(((IIndexInto)m_reportItemColInstance).GetChildAt(index, out nonCompNames));
 }
Пример #30
0
 internal override void ProcessDrillthroughAction(ReportProcessing.ProcessingContext processingContext, NonComputedUniqueNames nonCompNames)
 {
     if (m_action != null && nonCompNames != null)
     {
         m_action.ProcessDrillthroughAction(processingContext, nonCompNames.UniqueName);
     }
 }