Implement step 7.4.2: Column flow

Author: davidnmbond

PanoramicData.Render.Test/PageBuilderTests.cs

@@ -86,6 +86,24 @@ public void Paginate_BlocksExceedPageHeight_SpillToSecondPage()
 		result[1].Blocks.Should().ContainSingle();
 	}
 
+	[Fact]
+	public void Paginate_TwoColumnSection_UsesSecondColumnBeforeCreatingNewPage()
+	{
+		var section = new SectionInfo { ColumnCount = 2 };
+		var blocks = new[]
+		{
+			MakeBlock(7000f),
+			MakeBlock(7000f),
+			MakeBlock(7000f),
+		};
+
+		var result = PageBuilder.Paginate(blocks, section);
+
+		result.Should().HaveCount(2);
+		result[0].Blocks.Should().HaveCount(2);
+		result[1].Blocks.Should().ContainSingle();
+	}
+
 	[Fact]
 	public void Paginate_ManyBlocks_CorrectPageCount()
 	{

PanoramicData.Render.Test/RenderCommandEmitterTests.cs

@@ -142,6 +142,40 @@ public void EmitPage_TablePlaceholderBlock_EmitsDrawRectCommand()
 		target.DrawRectCalls[0].Rect.HeightTwips.Should().Be(800f);
 	}
 
+	[Fact]
+	public void EmitPage_WithBlockPlacements_UsesPlacementCoordinates()
+	{
+		var firstBlock = new LayoutBlock(new ParagraphBlock
+		{
+			SourceElement = new Paragraph(new Run(new Text("First")))
+		}, 300f);
+		var secondBlock = new LayoutBlock(new ParagraphBlock
+		{
+			SourceElement = new Paragraph(new Run(new Text("Second")))
+		}, 300f);
+		var page = new LayoutPage
+		{
+			Section = new SectionInfo { MarginLeft = 1440, MarginRight = 1440, PageWidth = 12240 },
+			PageNumber = 1,
+			ContentTopTwips = 1440,
+			Blocks = [firstBlock, secondBlock],
+			BlockPlacements =
+			[
+				new LayoutBlockPlacement(firstBlock, 1440f, 1440f, 4320f, 0),
+				new LayoutBlockPlacement(secondBlock, 6480f, 1440f, 4320f, 1)
+			]
+		};
+		var target = new FakeRenderTarget();
+
+		RenderCommandEmitter.EmitPage(page, target);
+
+		target.DrawTextCalls.Should().HaveCount(2);
+		target.DrawTextCalls[0].Text.Should().Be("First");
+		target.DrawTextCalls[0].BaselineXTwips.Should().Be(1440f);
+		target.DrawTextCalls[1].Text.Should().Be("Second");
+		target.DrawTextCalls[1].BaselineXTwips.Should().Be(6480f);
+	}
+
 	[Fact]
 	public void EmitDocument_MultiplePages_EmitsCommandsAcrossPages()
 	{

PanoramicData.Render/LayoutPage.cs

@@ -20,6 +20,12 @@ internal sealed class LayoutPage
 	/// </summary>
 	public required IReadOnlyList<LayoutBlock> Blocks { get; init; }
 
+	/// <summary>
+	/// Gets the positioned block placements for this page.
+	/// When empty, blocks are rendered as a single top-to-bottom stream.
+	/// </summary>
+	public IReadOnlyList<LayoutBlockPlacement> BlockPlacements { get; init; } = [];
+
 	/// <summary>
 	/// Gets the header layout blocks for this page, or <see langword="null"/> when no header applies.
 	/// </summary>
@@ -59,3 +65,18 @@ internal sealed class LayoutPage
 	/// </summary>
 	public float FootnoteTopTwips { get; init; }
 }
+
+/// <summary>
+/// Associates a layout block with its positioned content box on a page.
+/// </summary>
+/// <param name="Block">The block being placed.</param>
+/// <param name="XTwips">The X origin of the block's content region in twips.</param>
+/// <param name="YTwips">The Y origin of the block in twips.</param>
+/// <param name="ContentWidthTwips">The available content width for the block in twips.</param>
+/// <param name="ColumnIndex">The zero-based page column index containing the block.</param>
+internal readonly record struct LayoutBlockPlacement(
+	LayoutBlock Block,
+	float XTwips,
+	float YTwips,
+	float ContentWidthTwips,
+	int ColumnIndex);

PanoramicData.Render/PageBuilder.cs

@@ -195,6 +195,11 @@ private static IReadOnlyList<LayoutPage> PaginateStartingAt(
 			return [];
 		}
 
+		if (section.ColumnCount > 1)
+		{
+			return PaginateAcrossColumnsStartingAt(blocks, section, startPageNumber, headerHeight, footerHeight, footnoteHeight);
+		}
+
 		var availableHeight = ComputeAvailableContentHeight(section, headerHeight, footerHeight, footnoteHeight);
 		var pages = new List<LayoutPage>();
 		var currentPageBlocks = new List<LayoutBlock>();
@@ -241,7 +246,7 @@ private static IReadOnlyList<LayoutPage> PaginateStartingAt(
 					currentPageBlocks.RemoveRange(keepStart, pullBackCount);
 					currentHeight -= pulledBack.Sum(b => b.HeightTwips);
 
-					pages.Add(CreatePage(section, pageNumber, currentPageBlocks));
+					pages.Add(CreatePage(section, pageNumber, currentPageBlocks, headerHeight: headerHeight, footerHeight: footerHeight, footnoteHeight: footnoteHeight));
 					pageNumber++;
 					currentPageBlocks = new List<LayoutBlock>(pulledBack);
 					currentHeight = pulledBack.Sum(b => b.HeightTwips);
@@ -260,7 +265,7 @@ private static IReadOnlyList<LayoutPage> PaginateStartingAt(
 				{
 					// Place the first part on the current page, queue the second part.
 					currentPageBlocks.Add(split.Value.First);
-					pages.Add(CreatePage(section, pageNumber, currentPageBlocks));
+					pages.Add(CreatePage(section, pageNumber, currentPageBlocks, headerHeight: headerHeight, footerHeight: footerHeight, footnoteHeight: footnoteHeight));
 					pageNumber++;
 					currentPageBlocks = [];
 					currentHeight = 0f;
@@ -269,7 +274,7 @@ private static IReadOnlyList<LayoutPage> PaginateStartingAt(
 				else if (currentPageBlocks.Count > 0)
 				{
 					// Cannot split and page has content. Finalize page and retry on a fresh page.
-					pages.Add(CreatePage(section, pageNumber, currentPageBlocks));
+					pages.Add(CreatePage(section, pageNumber, currentPageBlocks, headerHeight: headerHeight, footerHeight: footerHeight, footnoteHeight: footnoteHeight));
 					pageNumber++;
 					currentPageBlocks = [];
 					currentHeight = 0f;
@@ -287,12 +292,134 @@ private static IReadOnlyList<LayoutPage> PaginateStartingAt(
 		// Finalize the last page.
 		if (currentPageBlocks.Count > 0)
 		{
-			pages.Add(CreatePage(section, pageNumber, currentPageBlocks));
+			pages.Add(CreatePage(section, pageNumber, currentPageBlocks, headerHeight: headerHeight, footerHeight: footerHeight, footnoteHeight: footnoteHeight));
 		}
 
 		return pages;
 	}
 
+	private static IReadOnlyList<LayoutPage> PaginateAcrossColumnsStartingAt(
+		IReadOnlyList<LayoutBlock> blocks,
+		SectionInfo section,
+		int startPageNumber,
+		float headerHeight = 0f,
+		float footerHeight = 0f,
+		float footnoteHeight = 0f)
+	{
+		var availableHeight = ComputeAvailableContentHeight(section, headerHeight, footerHeight, footnoteHeight);
+		var contentTop = ComputeContentTop(section, headerHeight);
+		var columns = ComputeColumnRegions(section);
+		var pages = new List<LayoutPage>();
+		var currentPageBlocks = new List<LayoutBlock>();
+		var currentPlacements = new List<LayoutBlockPlacement>();
+		var currentHeight = 0f;
+		var currentColumnIndex = 0;
+		var currentColumnHasBlocks = false;
+		var pageNumber = startPageNumber;
+
+		var index = 0;
+		LayoutBlock? pending = null;
+
+		while (index < blocks.Count || pending is not null)
+		{
+			var block = pending ?? blocks[index];
+			if (pending is null)
+			{
+				index++;
+			}
+
+			pending = null;
+
+			if (block.ForcePageBreakBefore && currentPageBlocks.Count > 0)
+			{
+				FinalizeCurrentPage();
+				pending = block;
+				continue;
+			}
+
+			if (currentHeight + block.HeightTwips <= availableHeight)
+			{
+				AddCurrentBlock(block);
+				continue;
+			}
+
+			var remainingSpace = currentColumnHasBlocks
+				? availableHeight - currentHeight
+				: availableHeight;
+
+			var split = TrySplitBlock(block, remainingSpace);
+
+			if (split is not null)
+			{
+				AddCurrentBlock(split.Value.First);
+				pending = split.Value.Second;
+				AdvanceColumnOrPage();
+				continue;
+			}
+
+			if (currentColumnHasBlocks)
+			{
+				pending = block;
+				AdvanceColumnOrPage();
+				continue;
+			}
+
+			AddCurrentBlock(block);
+		}
+
+		if (currentPageBlocks.Count > 0)
+		{
+			FinalizeCurrentPage();
+		}
+
+		return pages;
+
+		void AddCurrentBlock(LayoutBlock block)
+		{
+			var column = columns[currentColumnIndex];
+			currentPageBlocks.Add(block);
+			currentPlacements.Add(new LayoutBlockPlacement(
+				block,
+				column.XTwips,
+				contentTop + currentHeight,
+				column.WidthTwips,
+				currentColumnIndex));
+			currentHeight += block.HeightTwips;
+			currentColumnHasBlocks = true;
+		}
+
+		void AdvanceColumnOrPage()
+		{
+			if (currentColumnIndex + 1 < columns.Count)
+			{
+				currentColumnIndex++;
+				currentHeight = 0f;
+				currentColumnHasBlocks = false;
+				return;
+			}
+
+			FinalizeCurrentPage();
+		}
+
+		void FinalizeCurrentPage()
+		{
+			pages.Add(CreatePage(
+				section,
+				pageNumber,
+				currentPageBlocks,
+				currentPlacements,
+				headerHeight,
+				footerHeight,
+				footnoteHeight));
+			pageNumber++;
+			currentPageBlocks = [];
+			currentPlacements = [];
+			currentColumnIndex = 0;
+			currentHeight = 0f;
+			currentColumnHasBlocks = false;
+		}
+	}
+
 	/// <summary>
 	/// The default minimum number of lines for widow/orphan control.
 	/// </summary>
@@ -463,11 +590,20 @@ internal static IReadOnlyList<LayoutBlock> CreateTableRowLayoutBlocks(
 	private static LayoutPage CreatePage(
 		SectionInfo section,
 		int pageNumber,
-		List<LayoutBlock> blocks) => new()
+		List<LayoutBlock> blocks,
+		IReadOnlyList<LayoutBlockPlacement>? blockPlacements = null,
+		float headerHeight = 0f,
+		float footerHeight = 0f,
+		float footnoteHeight = 0f) => new()
 		{
 			Section = section,
 			PageNumber = pageNumber,
-			Blocks = blocks.ToArray()
+			Blocks = blocks.ToArray(),
+			BlockPlacements = blockPlacements?.ToArray() ?? [],
+			HeaderTopTwips = ComputeHeaderTop(section),
+			ContentTopTwips = ComputeContentTop(section, headerHeight),
+			FooterTopTwips = ComputeFooterTop(section, footerHeight),
+			FootnoteTopTwips = ComputeFootnoteTop(section, footerHeight, footnoteHeight)
 		};
 
 	/// <summary>
@@ -576,9 +712,37 @@ private static int ApplySectionBreak(
 	{
 		Section = section,
 		PageNumber = pageNumber,
-		Blocks = []
+		Blocks = [],
+		HeaderTopTwips = ComputeHeaderTop(section),
+		ContentTopTwips = ComputeContentTop(section),
+		FooterTopTwips = ComputeFooterTop(section),
+		FootnoteTopTwips = ComputeFootnoteTop(section)
 	};
 
+	private static IReadOnlyList<ColumnRegion> ComputeColumnRegions(SectionInfo section)
+	{
+		var contentLeft = section.MarginLeft;
+		var contentWidth = MathF.Max(0f, section.PageWidth - section.MarginLeft - section.MarginRight);
+		var columnCount = Math.Max(1, section.ColumnCount);
+		if (columnCount == 1)
+		{
+			return [new ColumnRegion(contentLeft, contentWidth)];
+		}
+
+		var spacing = MathF.Max(0f, section.ColumnSpacingTwips);
+		var totalSpacing = spacing * (columnCount - 1);
+		var columnWidth = MathF.Max(0f, (contentWidth - totalSpacing) / columnCount);
+		var result = new ColumnRegion[columnCount];
+		var currentX = (float)contentLeft;
+		for (var i = 0; i < columnCount; i++)
+		{
+			result[i] = new ColumnRegion(currentX, columnWidth);
+			currentX += columnWidth + spacing;
+		}
+
+		return result;
+	}
+
 	/// <summary>
 	/// Computes the available content height for body text, accounting for page dimensions,
 	/// margins, header/footer content heights, and footnote space.
@@ -649,4 +813,6 @@ internal static float ComputeFootnoteTop(SectionInfo section, float footerHeight
 
 	private static float ComputeEffectiveBottomMargin(SectionInfo section, float footerHeight)
 		=> Math.Max(section.MarginBottom, section.MarginFooter + footerHeight);
+
+	private readonly record struct ColumnRegion(float XTwips, float WidthTwips);
 }