Beispiel #1
0
 object ISearchByUniqueName.Find(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
 {
     return(((ISearchByUniqueName)this.m_reportItemColInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
 }
Beispiel #2
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)
        {
            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);
        }
        protected override object SearchChildren(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_tableGroupInstances != null)
            {
                int count = m_tableGroupInstances.Count;
                for (int j = 0; j < count; j++)
                {
                    obj = ((ISearchByUniqueName)m_tableGroupInstances[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);
        }
        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 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 virtual object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
 {
     return(null);
 }
 public ReportItemInstanceInfo GetInstanceInfo(ChunkManager.RenderingChunkManager chunkManager)
 {
     return(this.GetInstanceInfo(chunkManager, false));
 }
        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);
        }
 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));
 }
Beispiel #11
0
 internal ReportItemInstanceInfo GetInstanceInfo(ChunkManager.RenderingChunkManager chunkManager)
 {
     return(GetInstanceInfo(chunkManager, inPageSection: false));
 }
        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 (this.m_cornerContent != null)
                {
                    obj = ((ISearchByUniqueName)this.m_cornerContent).Find(targetUniqueName, ref nonCompNames, chunkManager);
                    if (obj != null)
                    {
                        return(obj);
                    }
                }
                else
                {
                    NonComputedUniqueNames cornerNonComputedNames = ((MatrixInstanceInfo)base.GetInstanceInfo(chunkManager, false)).CornerNonComputedNames;
                    obj = ((ISearchByUniqueName)matrix.CornerReportItems[0]).Find(targetUniqueName, ref cornerNonComputedNames, chunkManager);
                    if (obj != null)
                    {
                        nonCompNames = cornerNonComputedNames;
                        return(obj);
                    }
                }
            }
            obj = ((ISearchByUniqueName)this.m_columnInstances).Find(targetUniqueName, ref nonCompNames, chunkManager);
            if (obj != null)
            {
                return(obj);
            }
            obj = ((ISearchByUniqueName)this.m_rowInstances).Find(targetUniqueName, ref nonCompNames, chunkManager);
            if (obj != null)
            {
                return(obj);
            }
            int count = this.m_cells.Count;

            for (int i = 0; i < count; i++)
            {
                MatrixCellInstanceList matrixCellInstanceList = this.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 contentUniqueNames = instanceInfo.ContentUniqueNames;
                        obj = ((ISearchByUniqueName)matrix.CellReportItems[index]).Find(targetUniqueName, ref contentUniqueNames, chunkManager);
                        if (obj != null)
                        {
                            nonCompNames = contentUniqueNames;
                            return(obj);
                        }
                    }
                }
            }
            return(null);
        }
        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);
        }
 protected override object SearchChildren(int targetUniqueName, ref NonComputedUniqueNames nonCompNames, ChunkManager.RenderingChunkManager chunkManager)
 {
     return(((ISearchByUniqueName)m_reportItemColInstance).Find(targetUniqueName, ref nonCompNames, chunkManager));
 }
Beispiel #15
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);
        }