Create Repeating Table Header Row in PdfProcessing

Updated on Aug 6, 2026

Environment

Product Version	Product	Author
2021.1.113	RadPdfProcessing	Dimitar Karamfilov

Description

This article demonstrates how to create repeating header row functionality. When a table does not fit on a single page, you can repeat the header row on each subsequent page so the column headers remain visible.

Solution

The solution is to split the table on each page and draw a second table that contains only the headers. The following example shows the complete implementation that you can integrate into your application.

csharp

    class Program
    {
        private const string LoremIpsumText = @"Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam 
        nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud 
        exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in
        hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait.";
    
        private static readonly string[] headers = { "Header 1", "Header 2", "Header 3", "Header 4" };
        private static readonly Size pageSize = new Size(Unit.MmToDip(297), Unit.MmToDip(210));
        private static readonly double pageMargin = Unit.MmToDip(10);

        static void Main()
        {
            RadFixedDocument document = new RadFixedDocument();

            // Draw paragraph in the beginning splitting it onto pages.
            FixedContentEditor currentPageEditor = Program.CreateNewPage(document);
            Size availablePageSize = Program.CalculateRemainingSize(currentPageEditor);
            Block paragraph = Program.CreateParagraphInBeginningOfDocument();
            currentPageEditor.DrawBlock(paragraph, availablePageSize);

            while (paragraph.HasPendingContent)
            {
                paragraph = paragraph.Split();
                currentPageEditor = Program.CreateNewPage(document);
                currentPageEditor.DrawBlock(paragraph, availablePageSize);
            }

            // Start table on different page if there is not enough place for the first header row.
            currentPageEditor.Position.Translate(pageMargin, pageMargin + paragraph.DesiredSize.Height);
            Size remainingSize = Program.CalculateRemainingSize(currentPageEditor);
            Size repeatRowMeasureSize = new Size(CalculateRemainingWidth(), double.MaxValue);
            Size headerRowSize = CreateRepeatRowTable().Measure(repeatRowMeasureSize);

            if (headerRowSize.Height > remainingSize.Height)
            {
                currentPageEditor = Program.CreateNewPage(document);
            }
            
            // Draw table with repeating header row splitting it on multiple pages.
            Table table = Program.CreateTableWithData(150);                     
            do
            {
                if (table.HasPendingContent)
                {
                    currentPageEditor = Program.CreateNewPage(document);
                    table = table.Split();
                }

                Table rowToRepeat = Program.CreateRepeatRowTable();   
                currentPageEditor.DrawTable(rowToRepeat, repeatRowMeasureSize);
                currentPageEditor.Position.Translate(pageMargin, headerRowSize.Height + currentPageEditor.Position.Matrix.OffsetY);
                remainingSize = Program.CalculateRemainingSize(currentPageEditor);
                currentPageEditor.DrawTable(table, remainingSize);

            } while (table.HasPendingContent);
            
            ExportAndPreviewFile(document, "test.pdf");
        }

        private static FixedContentEditor CreateNewPage(RadFixedDocument document)
        {
            RadFixedPage currentPage = document.Pages.AddPage();
            currentPage.Size = pageSize;
            FixedContentEditor currentPageEditor = new FixedContentEditor(currentPage);
            currentPageEditor.Position.Translate(pageMargin, pageMargin);

            return currentPageEditor;
        }

        private static Block CreateParagraphInBeginningOfDocument()
        {
            Block block = new Block();
            block.InsertText(Program.GetParagraphText(8));

            return block;
        }

        private static string GetParagraphText(int repeatCount)
        {
            StringBuilder builder = new StringBuilder();

            for (int i = 0; i < repeatCount; i++)
            {
                builder.Append(LoremIpsumText);
            }

            return builder.ToString();
        }

        private static Table CreateRepeatRowTable()
        {
            return CreateTableWithData(1, (row, column) => headers[column]);
        }

        private static Table CreateTableWithData(int numberOfRows)
        {
            return CreateTableWithData(numberOfRows, (row, column) => string.Format("data in row{0} column{1}", row, column));
        }

        private static Table CreateTableWithData(int numberOfRows, Func<int, int, string> getDataByRowColumn)
        {
            Table table = new Table();
            Border border = new Border(1, new RgbColor(0, 0, 0));
            table.DefaultCellProperties.Borders = new TableCellBorders(border, border, border, border);
            double cellWidth = (CalculateRemainingWidth()) / headers.Length;

            for (int rowIndex = 0; rowIndex < numberOfRows; rowIndex++)
            {
                TableRow row = table.Rows.AddTableRow();

                for (int columnIndex = 0; columnIndex < headers.Length; columnIndex++)
                {
                    TableCell cell = row.Cells.AddTableCell();
                    cell.Blocks.AddBlock().InsertText(getDataByRowColumn(rowIndex, columnIndex));
                    cell.PreferredWidth = cellWidth;
                }
            }

            return table;
        }

        private static Size CalculateRemainingSize(FixedContentEditor editor)
        {
            return new Size(CalculateRemainingWidth(), pageSize.Height - pageMargin - editor.Position.Matrix.OffsetY);
        }

        private static double CalculateRemainingWidth()
        {
            return pageSize.Width - 2 * pageMargin;
        }

        private static void ExportAndPreviewFile(RadFixedDocument document, string fileName)
        {
            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }

            File.WriteAllBytes(fileName, new PdfFormatProvider().Export(document));

            Process.Start(fileName);
        }
    }

See Also

• RadPdfProcessing Overview
• PDF Table Overview
• FixedContentEditor