private void CommonInitialize(int level, DataCellsList dataRowCells, ref int currentIndex, ref int maxLevel, InitializationContext context)
 {
     base.Initialize(context);
     if (this.m_customProperties != null)
     {
         context.RegisterRunningValues(this.m_runningValues);
         this.m_customProperties.Initialize(null, true, context);
         context.UnRegisterRunningValues(this.m_runningValues);
     }
     if (this.m_innerHeadings != null)
     {
         Global.Tracer.Assert(null != context.AggregateEscalateScopes);
         if (base.m_grouping != null)
         {
             context.AggregateEscalateScopes.Add(base.m_grouping.Name);
         }
         base.m_headingSpan += this.m_innerHeadings.Initialize(level + 1, dataRowCells, ref currentIndex, ref maxLevel, context);
         if (base.m_grouping != null)
         {
             context.AggregateEscalateScopes.RemoveAt(context.AggregateEscalateScopes.Count - 1);
         }
     }
     else
     {
         currentIndex++;
     }
 }
Beispiel #2
0
        public int Initialize(int level, DataCellsList dataRowCells, ref int currentIndex, ref int maxLevel, InitializationContext context)
        {
            int num  = this.Count;
            int num2 = 0;

            for (int i = 0; i < num; i++)
            {
                Global.Tracer.Assert(null != this[i]);
                if (this[i].Initialize(level, this, i, dataRowCells, ref currentIndex, ref maxLevel, context))
                {
                    num++;
                    num2 += this[i].HeadingSpan;
                }
            }
            return(num2);
        }
        private static CustomReportItemHeadingList HeadingListClone(CustomReportItemHeadingList headings, DataCellsList dataRowCells, ref int currentIndex, int headingSpan, InitializationContext context)
        {
            if (headings == null)
            {
                return(null);
            }
            int count = headings.Count;

            Global.Tracer.Assert(1 <= count);
            CustomReportItemHeadingList customReportItemHeadingList = new CustomReportItemHeadingList(count);

            for (int i = 0; i < count; i++)
            {
                CustomReportItemHeading customReportItemHeading = headings[i];
                if (customReportItemHeading.m_grouping != null)
                {
                    context.AggregateRewriteScopes.Add(customReportItemHeading.m_grouping.Name, null);
                }
                CustomReportItemHeading customReportItemHeading2 = CustomReportItemHeading.HeadingClone(customReportItemHeading, dataRowCells, ref currentIndex, headingSpan, context);
                if (customReportItemHeading.m_innerHeadings != null)
                {
                    customReportItemHeading2.m_innerHeadings = CustomReportItemHeading.HeadingListClone(customReportItemHeading.m_innerHeadings, dataRowCells, ref currentIndex, headingSpan, context);
                }
                if (customReportItemHeading.m_grouping != null)
                {
                    context.AggregateRewriteScopes.Remove(customReportItemHeading.m_grouping.Name);
                }
                customReportItemHeadingList.Add(customReportItemHeading2);
            }
            return(customReportItemHeadingList);
        }
        private static CustomReportItemHeading HeadingClone(CustomReportItemHeading heading, DataCellsList dataRowCells, ref int currentIndex, int headingSpan, InitializationContext context)
        {
            Global.Tracer.Assert(null != heading);
            CustomReportItemHeading customReportItemHeading = new CustomReportItemHeading(context.GenerateSubtotalID(), (CustomReportItem)heading.DataRegionDef);

            customReportItemHeading.m_isColumn    = heading.m_isColumn;
            customReportItemHeading.m_level       = heading.m_level;
            customReportItemHeading.m_static      = true;
            customReportItemHeading.m_subtotal    = false;
            customReportItemHeading.m_headingSpan = heading.m_headingSpan;
            if (heading.m_customProperties != null)
            {
                customReportItemHeading.m_customProperties = heading.m_customProperties.DeepClone(context);
            }
            if (heading.m_innerHeadings == null)
            {
                if (heading.m_isColumn)
                {
                    int count = dataRowCells.Count;
                    for (int i = 0; i < count; i++)
                    {
                        DataCellList dataCellList = dataRowCells[i];
                        Global.Tracer.Assert(currentIndex + headingSpan <= dataCellList.Count);
                        dataCellList.Insert(currentIndex + headingSpan, dataCellList[currentIndex].DeepClone(context));
                    }
                }
                else
                {
                    Global.Tracer.Assert(currentIndex + headingSpan <= dataRowCells.Count);
                    DataCellList dataCellList2 = dataRowCells[currentIndex];
                    int          count2        = dataCellList2.Count;
                    DataCellList dataCellList3 = new DataCellList(count2);
                    dataRowCells.Insert(currentIndex + headingSpan, dataCellList3);
                    for (int j = 0; j < count2; j++)
                    {
                        dataCellList3.Add(dataCellList2[j].DeepClone(context));
                    }
                }
                currentIndex++;
            }
            return(customReportItemHeading);
        }
 public bool Initialize(int level, CustomReportItemHeadingList peerHeadings, int headingIndex, DataCellsList dataRowCells, ref int currentIndex, ref int maxLevel, InitializationContext context)
 {
     base.m_level = level;
     if (level > maxLevel)
     {
         maxLevel = level;
     }
     context.ExprHostBuilder.DataGroupingStart(base.m_isColumn);
     if (this.m_static)
     {
         Global.Tracer.Assert(!base.m_subtotal);
         if (base.m_grouping != null)
         {
             context.ErrorContext.Register(ProcessingErrorCode.rsInvalidStaticDataGrouping, Severity.Error, context.ObjectType, context.ObjectName, "DataGrouping");
             base.m_grouping = null;
         }
         else
         {
             base.m_sorting = null;
             this.CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
         }
     }
     else
     {
         if ((context.Location & LocationFlags.InDetail) != 0)
         {
             context.ErrorContext.Register(ProcessingErrorCode.rsInvalidDetailDataGrouping, Severity.Error, context.ObjectType, context.ObjectName, "DataGrouping");
             return(false);
         }
         if (base.m_grouping != null && base.m_grouping.CustomProperties != null)
         {
             if (this.m_customProperties == null)
             {
                 this.m_customProperties = new DataValueList(base.m_grouping.CustomProperties.Count);
             }
             this.m_customProperties.AddRange(base.m_grouping.CustomProperties);
             base.m_grouping.CustomProperties = null;
         }
         if (base.m_subtotal)
         {
             if (base.m_grouping != null)
             {
                 context.AggregateRewriteScopes = new Hashtable();
                 context.AggregateRewriteScopes.Add(base.m_grouping.Name, null);
             }
             Global.Tracer.Assert(null != peerHeadings[headingIndex]);
             int num = currentIndex;
             CustomReportItemHeading customReportItemHeading = CustomReportItemHeading.HeadingClone(this, dataRowCells, ref num, base.m_headingSpan, context);
             customReportItemHeading.m_innerHeadings = CustomReportItemHeading.HeadingListClone(this.m_innerHeadings, dataRowCells, ref num, base.m_headingSpan, context);
             Global.Tracer.Assert(currentIndex + base.m_headingSpan == num);
             Global.Tracer.Assert(!customReportItemHeading.m_subtotal && base.m_subtotal);
             Global.Tracer.Assert(headingIndex < peerHeadings.Count);
             peerHeadings.Insert(headingIndex + 1, customReportItemHeading);
             context.AggregateRewriteScopes = null;
             context.AggregateRewriteMap    = null;
         }
         if (base.m_grouping != null)
         {
             context.Location |= LocationFlags.InGrouping;
             context.RegisterGroupingScope(base.m_grouping.Name, base.m_grouping.SimpleGroupExpressions, base.m_grouping.Aggregates, base.m_grouping.PostSortAggregates, base.m_grouping.RecursiveAggregates, base.m_grouping);
             ObjectType objectType = context.ObjectType;
             string     objectName = context.ObjectName;
             context.ObjectType = ObjectType.Grouping;
             context.ObjectName = base.m_grouping.Name;
             this.CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
             context.ObjectType = objectType;
             context.ObjectName = objectName;
             context.UnRegisterGroupingScope(base.m_grouping.Name);
         }
         else
         {
             context.Location |= LocationFlags.InDetail;
             this.CommonInitialize(level, dataRowCells, ref currentIndex, ref maxLevel, context);
         }
     }
     this.m_exprHostID   = context.ExprHostBuilder.DataGroupingEnd(base.m_isColumn);
     base.m_hasExprHost |= (this.m_exprHostID >= 0);
     return(base.m_subtotal);
 }