public static void CalculateColumnZIndexes(RPLTablix tablix, RPLTablixRow row, int currentRow, int[] columnZIndexes)
 {
     if (currentRow < tablix.ColumnHeaderRows)
     {
         for (int i = 0; i < row.NumCells; i++)
         {
             RPLTablixMemberCell rPLTablixMemberCell = row[i] as RPLTablixMemberCell;
             if (rPLTablixMemberCell != null)
             {
                 columnZIndexes[rPLTablixMemberCell.ColIndex] = Math.Min(columnZIndexes[rPLTablixMemberCell.ColIndex], SharedRenderer.CalculateZIndex(rPLTablixMemberCell));
             }
         }
     }
     else
     {
         for (int j = 0; j < row.NumCells; j++)
         {
             RPLTablixMemberCell rPLTablixMemberCell2 = row[j] as RPLTablixMemberCell;
             if (rPLTablixMemberCell2 != null)
             {
                 columnZIndexes[rPLTablixMemberCell2.ColIndex] = SharedRenderer.CalculateZIndex(rPLTablixMemberCell2);
             }
         }
     }
 }
        public static int CalculateZIndex(RPLTablixMemberCell header)
        {
            int num = header.TablixMemberDef.Level * 3;

            if (!header.TablixMemberDef.StaticHeadersTree)
            {
                num--;
            }
            return(num);
        }
        private int CalculateZIndex(RPLTablixMemberCell header, bool forHeader)
        {
            int num = header.TablixMemberDef.Level * 3;

            if (!header.TablixMemberDef.StaticHeadersTree)
            {
                num--;
            }
            if (!forHeader)
            {
                num--;
            }
            return(num);
        }
Example #4
0
 public void SetIndexes(RPLTablixMemberCell member, bool isColumn)
 {
     if (member.TablixMemberDef.IsStatic)
     {
         if (this.m_staticBeforeIndex == -1 && this.m_toggleIndex == -1)
         {
             this.m_staticBeforeIndex = (isColumn ? member.ColIndex : member.RowIndex);
         }
         if (this.m_staticAfterIndex == -1 && this.m_toggleIndex > -1)
         {
             this.m_staticAfterIndex = (isColumn ? member.ColIndex : member.RowIndex);
         }
     }
     else if (member.HasToggle && this.m_toggleIndex == -1)
     {
         this.m_toggleIndex = (isColumn ? member.ColIndex : member.RowIndex);
     }
 }
        public static int CalculateRowZIndex(RPLTablixRow row)
        {
            int num = 2147483647;

            for (int i = 0; i < row.NumCells; i++)
            {
                RPLTablixMemberCell rPLTablixMemberCell = row[i] as RPLTablixMemberCell;
                if (rPLTablixMemberCell != null)
                {
                    num = Math.Min(num, SharedRenderer.CalculateZIndex(rPLTablixMemberCell));
                }
            }
            if (row.OmittedHeaders != null && row.OmittedHeaders.Count > 0)
            {
                for (int j = 0; j < row.OmittedHeaders.Count; j++)
                {
                    num = Math.Min(num, SharedRenderer.CalculateZIndex(row.OmittedHeaders[j]));
                }
            }
            return(num);
        }
        internal static int CalculateRowZIndex(RPLTablixRow row)
        {
            int num = int.MaxValue;

            for (int i = 0; i < row.NumCells; i++)
            {
                RPLTablixMemberCell rPLTablixMemberCell = row[i] as RPLTablixMemberCell;
                if (rPLTablixMemberCell != null)
                {
                    num = Math.Min(num, CalculateZIndex(rPLTablixMemberCell));
                }
            }
            if (row.OmittedHeaders != null && row.OmittedHeaders.Count > 0)
            {
                for (int j = 0; j < row.OmittedHeaders.Count; j++)
                {
                    num = Math.Min(num, CalculateZIndex(row.OmittedHeaders[j]));
                }
            }
            return(num);
        }
Example #7
0
 private static bool SetRelativeStaticLocation(RPLTablixMemberCell member, ALayout layout, RelativeStaticLocation staticLocation, List <RelativeStaticLocation> rowHeaderStaticLocations, ref bool isColumn)
 {
     if (member.TablixMemberDef.IsColumn)
     {
         isColumn = true;
         if (!layout.SummaryColumnAfter.HasValue)
         {
             if (member.IsRecursiveToggle)
             {
                 layout.SummaryColumnAfter = false;
             }
             else
             {
                 staticLocation.SetIndexes(member, true);
             }
         }
     }
     else
     {
         isColumn = false;
         if (!layout.SummaryRowAfter.HasValue)
         {
             if (member.IsRecursiveToggle)
             {
                 layout.SummaryRowAfter = false;
             }
             else
             {
                 int level = member.TablixMemberDef.Level;
                 for (int i = rowHeaderStaticLocations.Count; i <= level; i++)
                 {
                     rowHeaderStaticLocations.Add(new RelativeStaticLocation());
                 }
                 RelativeStaticLocation relativeStaticLocation = rowHeaderStaticLocations[level];
                 relativeStaticLocation.SetIndexes(member, false);
             }
         }
     }
     return(member.HasToggle);
 }
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            RPLTablix       rPLTablix        = (RPLTablix)rplElement;
            FixedHeaderItem fixedHeaderItem  = null;
            FixedHeaderItem fixedHeaderItem2 = null;
            FixedHeaderItem fixedHeaderItem3 = null;
            float           num  = 0f;
            float           num2 = bounds.Top;

            float[] array = null;
            array = ((rPLTablix.ColumnWidths == null) ? new float[0] : new float[rPLTablix.ColumnWidths.Length]);
            int[] array2 = new int[array.Length];
            for (int i = 0; i < array2.Length; i++)
            {
                array2[i] = int.MaxValue;
            }
            for (int j = 0; j < array.Length; j++)
            {
                if (j > 0)
                {
                    array[j] = array[j - 1] + rPLTablix.ColumnWidths[j - 1];
                }
                if (rPLTablix.FixedColumns[j])
                {
                    if (fixedHeaderItem3 == null)
                    {
                        fixedHeaderItem3              = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Vertical);
                        fixedHeaderItem3.Bounds.X    += array[j];
                        fixedHeaderItem3.Bounds.Width = rPLTablix.ColumnWidths[j];
                    }
                    else
                    {
                        fixedHeaderItem3.Bounds.X      = Math.Min(fixedHeaderItem3.Bounds.X, base.Position.X + array[j]);
                        fixedHeaderItem3.Bounds.Width += rPLTablix.ColumnWidths[j];
                    }
                }
            }
            if (rPLTablix.FixedRow(0))
            {
                fixedHeaderItem = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Horizontal);
                fixedHeaderItem.Bounds.Height = 0f;
                context.RenderingReport.FixedHeaders.Add(fixedHeaderItem);
            }
            if (fixedHeaderItem3 != null)
            {
                context.RenderingReport.FixedHeaders.Add(fixedHeaderItem3);
                if (rPLTablix.FixedRow(0))
                {
                    fixedHeaderItem2 = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Corner);
                    context.RenderingReport.FixedHeaders.Add(fixedHeaderItem2);
                }
            }
            int          num3 = 0;
            int          num4 = -1;
            RPLTablixRow nextRow;

            while ((nextRow = rPLTablix.GetNextRow()) != null)
            {
                if (nextRow is RPLTablixOmittedRow)
                {
                    continue;
                }
                SharedRenderer.CalculateColumnZIndexes(rPLTablix, nextRow, num3, array2);
                if (nextRow.OmittedHeaders != null)
                {
                    for (int k = 0; k < nextRow.OmittedHeaders.Count; k++)
                    {
                        RPLTablixMemberCell rPLTablixMemberCell = nextRow.OmittedHeaders[k];
                        if (!string.IsNullOrEmpty(rPLTablixMemberCell.GroupLabel))
                        {
                            float x = bounds.X;
                            if (rPLTablixMemberCell.ColIndex < array.Length)
                            {
                                x = array[rPLTablixMemberCell.ColIndex];
                            }
                            context.RenderingReport.Labels.Add(rPLTablixMemberCell.UniqueName, new LabelPoint(x, num2));
                        }
                    }
                }
                int num5 = int.MaxValue;
                for (int l = 0; l < nextRow.NumCells; l++)
                {
                    RPLTablixCell      rPLTablixCell      = nextRow[l];
                    RPLItemMeasurement rPLItemMeasurement = new RPLItemMeasurement();
                    rPLItemMeasurement.Element = rPLTablixCell.Element;
                    rPLItemMeasurement.Left    = array[rPLTablixCell.ColIndex];
                    rPLItemMeasurement.Top     = num;
                    rPLItemMeasurement.Width   = rPLTablix.GetColumnWidth(rPLTablixCell.ColIndex, rPLTablixCell.ColSpan);
                    rPLItemMeasurement.Height  = rPLTablix.GetRowHeight(rPLTablixCell.RowIndex, rPLTablixCell.RowSpan);
                    RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLItemMeasurement, bounds);
                    if (renderingItem == null)
                    {
                        continue;
                    }
                    if (renderingItem is RenderingDynamicImage)
                    {
                        ((RenderingDynamicImage)renderingItem).Sizing = RPLFormat.Sizings.Fit;
                    }
                    RPLTablixMemberCell rPLTablixMemberCell2 = rPLTablixCell as RPLTablixMemberCell;
                    if (rPLTablixMemberCell2 != null && !string.IsNullOrEmpty(rPLTablixMemberCell2.GroupLabel))
                    {
                        context.RenderingReport.Labels.Add(rPLTablixMemberCell2.UniqueName, new LabelPoint(rPLItemMeasurement.Left, rPLItemMeasurement.Top));
                    }
                    if (renderingItem.HasBorders)
                    {
                        renderingItem.DelayDrawBorders = true;
                        if (num3 < rPLTablix.ColumnHeaderRows && rPLTablixCell is RPLTablixCornerCell)
                        {
                            m_cornerBorders.Add(new RenderingItemBorderTablix(0, 0, rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem));
                        }
                        else
                        {
                            if (num5 == int.MaxValue)
                            {
                                num5 = SharedRenderer.CalculateRowZIndex(nextRow);
                            }
                            if (num5 == int.MaxValue)
                            {
                                num5 = num4;
                            }
                            RenderingItemBorderTablix renderingItemBorderTablix = new RenderingItemBorderTablix(num5, array2[rPLTablixCell.ColIndex], rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem);
                            if (rPLTablixMemberCell2 != null)
                            {
                                if (num3 < rPLTablix.ColumnHeaderRows)
                                {
                                    m_columnHeaderBorders.Add(renderingItemBorderTablix);
                                }
                                else
                                {
                                    renderingItemBorderTablix.CompareRowFirst = false;
                                    m_rowHeaderBorders.Add(renderingItemBorderTablix);
                                }
                            }
                            else
                            {
                                m_detailCellBorders.Add(renderingItemBorderTablix);
                            }
                        }
                    }
                    base.Children.Add(renderingItem);
                    fixedHeaderItem?.RenderingItems.Add(renderingItem);
                    if (rPLTablix.FixedColumns[rPLTablixCell.ColIndex])
                    {
                        fixedHeaderItem3.RenderingItems.Add(renderingItem);
                    }
                    if (fixedHeaderItem2 != null && rPLTablixCell is RPLTablixCornerCell)
                    {
                        fixedHeaderItem2.RenderingItems.Add(renderingItem);
                        fixedHeaderItem2.Bounds = renderingItem.Position;
                    }
                }
                num4 = num5;
                if (fixedHeaderItem != null)
                {
                    fixedHeaderItem.Bounds.Height += rPLTablix.RowHeights[num3];
                    if (num3 == rPLTablix.RowHeights.Length - 1 || !rPLTablix.FixedRow(num3 + 1))
                    {
                        fixedHeaderItem = null;
                    }
                }
                num  += rPLTablix.RowHeights[num3];
                num2 += rPLTablix.RowHeights[num3];
                num3++;
                for (int m = 0; m < nextRow.NumCells; m++)
                {
                    nextRow[m] = null;
                }
            }
            m_detailCellBorders.Sort(new ZIndexComparer());
            m_columnHeaderBorders.Sort(new ZIndexComparer());
            m_rowHeaderBorders.Sort(new ZIndexComparer());
            m_cornerBorders.Sort(new ZIndexComparer());
            RectangleF position = base.Position;

            if (array.Length != 0)
            {
                position.Width = array[array.Length - 1] + rPLTablix.ColumnWidths[rPLTablix.ColumnWidths.Length - 1];
            }
            position.Height = num;
        }
Example #9
0
 public abstract void AddStructuralItem(int top, int left, int width, int height, bool isToggglable, int generationIndex, RPLTablixMemberCell member, TogglePosition togglePosition);
Example #10
0
 internal override void AddStructuralItem(int top, int left, int width, int height, bool isToggglable, int generationIndex, RPLTablixMemberCell member, TogglePosition togglePosition)
 {
 }
Example #11
0
        private static void ReadTablixCellProperties(RPLTablixCell cell, ALayout layout, int[] rowTops, int[] columnLefts, int generationIndex, bool isRTL, BlockOutlines blockOutlines, Dictionary <string, ToggleParent> toggleParents, bool suppressOutlines, string subreportLanguage)
        {
            int  num  = columnLefts[cell.ColIndex];
            int  num2 = rowTops[cell.RowIndex];
            int  num3 = columnLefts[cell.ColIndex + cell.ColSpan] - num;
            int  num4 = rowTops[cell.RowIndex + cell.RowSpan] - num2;
            bool flag = false;

            if (num3 == 0 && cell.ColSpan != 0)
            {
                return;
            }
            if (num4 == 0 && cell.RowSpan != 0)
            {
                return;
            }
            if (!suppressOutlines && cell is RPLTablixMemberCell && blockOutlines != (BlockOutlines)3)
            {
                RPLTablixMemberCell rPLTablixMemberCell = (RPLTablixMemberCell)cell;
                TogglePosition      togglePosition      = TogglePosition.None;
                flag = rPLTablixMemberCell.HasToggle;
                if (rPLTablixMemberCell.TablixMemberDef.IsColumn)
                {
                    if ((blockOutlines & BlockOutlines.Columns) != 0)
                    {
                        flag = false;
                    }
                    togglePosition = TogglePosition.Above;
                }
                else
                {
                    if ((blockOutlines & BlockOutlines.Rows) != 0)
                    {
                        flag = false;
                    }
                    togglePosition = (TogglePosition)((!isRTL) ? 1 : 2);
                }
                int left = num;
                if (isRTL && num3 == 0 && cell.ColIndex > 0)
                {
                    left = columnLefts[cell.ColIndex - 1];
                }
                layout.AddStructuralItem(num2, left, num3, num4, flag, generationIndex, rPLTablixMemberCell, togglePosition);
            }
            RPLItem element = cell.Element;

            if (element != null)
            {
                byte         b         = default(byte);
                RPLItemProps itemProps = layout.RPLReport.GetItemProps(element.RPLSource, out b);
                if (b == 7)
                {
                    RPLTextBoxPropsDef rPLTextBoxPropsDef = (RPLTextBoxPropsDef)itemProps.Definition;
                    if (rPLTextBoxPropsDef.IsSimple)
                    {
                        layout.AddReportItem(element.RPLSource, num2, num, num3, num4, generationIndex, cell.ElementState, subreportLanguage, toggleParents);
                    }
                    else
                    {
                        layout.AddReportItem(element, num2, num, num3, num4, generationIndex, cell.ElementState, subreportLanguage, toggleParents);
                    }
                    if (!suppressOutlines && rPLTextBoxPropsDef.IsToggleParent && !toggleParents.ContainsKey(rPLTextBoxPropsDef.Name))
                    {
                        toggleParents.Add(rPLTextBoxPropsDef.Name, new ToggleParent(num2, num, num3, num4));
                    }
                }
                else
                {
                    layout.AddReportItem(element.RPLSource, num2, num, num3, num4, generationIndex, cell.ElementState, subreportLanguage, toggleParents);
                }
                if (!suppressOutlines)
                {
                    if (rowTops.Length > 2)
                    {
                        blockOutlines |= BlockOutlines.Columns;
                    }
                    if (columnLefts.Length > 2)
                    {
                        blockOutlines |= BlockOutlines.Rows;
                    }
                }
                Reader.ReadMeasurement(element, layout, num2, num, generationIndex + 1, blockOutlines, toggleParents, suppressOutlines, num3, subreportLanguage);
            }
        }
Example #12
0
 private static void ReadTablixStructure(RPLTablix tablix, ALayout layout, int top, int left, int generationIndex, BlockOutlines blockOutlines, Dictionary <string, ToggleParent> toggleParents, bool suppressOutlines, string subreportLanguage)
 {
     if (tablix != null)
     {
         int num = 0;
         if (tablix.ColumnWidths != null)
         {
             num = tablix.ColumnWidths.Length;
         }
         int[] array = new int[num + 1];
         array[0] = left;
         double num2           = (double)left;
         int    num3           = 0;
         int    rowHeaderWidth = 0;
         for (int i = 1; i <= num; i++)
         {
             num2    += LayoutConvert.ConvertMMTo20thPointsUnrounded((double)tablix.ColumnWidths[i - 1]);
             array[i] = (int)Math.Round(num2);
             if (tablix.ColsBeforeRowHeaders == 0 && i == tablix.RowHeaderColumns)
             {
                 rowHeaderWidth = (int)Math.Round(num2 - (double)left);
             }
         }
         num3 = (int)Math.Round(num2 - (double)left);
         int num4 = 0;
         if (tablix.RowHeights != null)
         {
             num4 = tablix.RowHeights.Length;
         }
         int[] array2 = new int[num4 + 1];
         array2[0] = top;
         double num5 = (double)top;
         int    num6 = 0;
         int    columnHeaderHeight = 0;
         for (int j = 1; j <= num4; j++)
         {
             num5     += LayoutConvert.ConvertMMTo20thPointsUnrounded((double)tablix.RowHeights[j - 1]);
             array2[j] = (int)Math.Round(num5);
             if (j == tablix.ColumnHeaderRows)
             {
                 columnHeaderHeight = (int)Math.Round(num5 - (double)top);
             }
         }
         num6 = (int)Math.Round(num5 - (double)top);
         List <RelativeStaticLocation> list = new List <RelativeStaticLocation>();
         bool         flag = false;
         RPLTablixRow nextRow;
         while ((nextRow = tablix.GetNextRow()) != null)
         {
             bool flag2 = false;
             RelativeStaticLocation relativeStaticLocation = new RelativeStaticLocation();
             if (!suppressOutlines && nextRow.OmittedHeaders != null)
             {
                 for (int k = 0; k < nextRow.OmittedHeaders.Count; k++)
                 {
                     RPLTablixMemberCell rPLTablixMemberCell = nextRow.OmittedHeaders[k];
                     if (Reader.SetRelativeStaticLocation(rPLTablixMemberCell, layout, relativeStaticLocation, list, ref flag2))
                     {
                         flag = true;
                     }
                     Reader.ReadTablixCellProperties(rPLTablixMemberCell, layout, array2, array, generationIndex + 1, tablix.LayoutDirection == RPLFormat.Directions.RTL, blockOutlines, toggleParents, suppressOutlines, subreportLanguage);
                     nextRow.OmittedHeaders[k] = null;
                 }
             }
             for (int l = 0; l < nextRow.NumCells; l++)
             {
                 RPLTablixCell rPLTablixCell = nextRow[l];
                 if (!suppressOutlines)
                 {
                     RPLTablixMemberCell rPLTablixMemberCell2 = rPLTablixCell as RPLTablixMemberCell;
                     if (rPLTablixMemberCell2 != null && Reader.SetRelativeStaticLocation(rPLTablixMemberCell2, layout, relativeStaticLocation, list, ref flag2))
                     {
                         flag = true;
                     }
                 }
                 Reader.ReadTablixCellProperties(rPLTablixCell, layout, array2, array, generationIndex + 1, tablix.LayoutDirection == RPLFormat.Directions.RTL, blockOutlines, toggleParents, suppressOutlines, subreportLanguage);
                 nextRow[l] = null;
             }
             if (!suppressOutlines && flag2 && !layout.SummaryColumnAfter.HasValue)
             {
                 layout.SummaryColumnAfter = relativeStaticLocation.IsSummaryAfter();
             }
         }
         if (!suppressOutlines)
         {
             int num7 = 0;
             while (!layout.SummaryRowAfter.HasValue && num7 < list.Count)
             {
                 RelativeStaticLocation relativeStaticLocation2 = list[num7];
                 layout.SummaryRowAfter = relativeStaticLocation2.IsSummaryAfter();
                 num7++;
             }
             if (flag)
             {
                 layout.AddStructuralItem(top, left, num3, num6, ALayout.TablixStructStart + ALayout.TablixStructGenerationOffset * generationIndex, rowHeaderWidth, columnHeaderHeight, tablix.LayoutDirection == RPLFormat.Directions.RTL);
             }
         }
     }
 }